A Low Power Node (LPN) is a mesh node that cannot afford to keep its radio on all the time. Examples include door sensors, occupancy detectors, and environmental sensors running on small batteries.

The spec says an LPN must support three operations:

• Low Power Establishment — finding and pairing with a Friend
• Low Power Messaging — polling the Friend for queued messages
• Low Power Management — telling the Friend which group addresses to track

All control messages from an LPN go out as Unsegmented Control messages with TTL = 0, meaning they don’t relay through other nodes — they’re point-to-point with the Friend.

Before the LPN can sleep and still receive messages, it needs to “pair” with a nearby Friend node. This pairing is called friendship establishment. Here’s the step-by-step:

A few important details from the spec worth noting:

• The LPN keeps a counter called LPNCounter (2 bytes, starts at 0). It goes into every Friend Request and is used to derive the security keys for that friendship. It increments after each request.
• If no Friend Offer arrives, the LPN can try again — but it must wait at least 1.1 seconds between consecutive Friend Requests.
• If the LPN tries ~6 times with no success, it may signal a deeper problem: an invalid IV Index, which triggers the IV Index Recovery procedure.

BlueZ exposes mesh node features via D-Bus. You can query or configure Low Power Node behaviour through the org.bluez.mesh.Node1 interface. Below is a quick reference using gdbus and the BlueZ mesh daemon (bluetooth-meshd).

Check if meshd is running:

# Start the BlueZ mesh daemon
sudo bluetooth-meshd --nodetach --debug

# In another terminal, check D-Bus mesh objects
gdbus introspect --system \
  --dest org.bluez.mesh \
  --object-path /org/bluez/mesh

Enable Low Power Feature when creating a node (mesh-cfgclient example):

/* When provisioning a node, set its features bitmask.
 * Bit 2 = Low Power feature
 * Bit 1 = Friend feature
 * These are set in the node's composition data (Page 0).
 */

/* Example: read composition data page 0 via config client */
mesh-cfgclient
[mesh-cfgclient]# connect
[mesh-cfgclient]# get-composition 0x0100 0

Friend Poll timer — conceptual flow in C (BlueZ mesh source style):

/*
 * Simplified version of how BlueZ mesh handles
 * the PollTimeout for a Low Power Node.
 * Source reference: mesh/friend.c in BlueZ source
 */

#include <stdint.h>
#include <stdbool.h>

#define POLL_TIMEOUT_MS   10000   /* 10 seconds example */
#define RECEIVE_DELAY_MS  100
#define RECEIVE_WINDOW_MS 250

struct lpn_state {
    uint16_t lpn_counter;      /* LPNCounter, 2 bytes */
    uint8_t  fsn;              /* Friend Sequence Number (0 or 1) */
    bool     friendship_active;
    uint32_t poll_timeout_ms;
};

/* Called when LPN wakes up to request queued messages */
void lpn_send_friend_poll(struct lpn_state *lpn)
{
    /* FSN field reflects current Friend Sequence Number */
    uint8_t fsn = lpn->fsn;

    /* Build and send Friend Poll with TTL=0 */
    /* mesh_send_friend_poll(dst_friend_addr, fsn); */

    /* Wait for Friend Update/message within ReceiveWindow */
    /* If no reply: retry up to 3 times */
}

/* Toggle FSN after receiving a non-duplicate response */
void lpn_on_valid_response(struct lpn_state *lpn)
{
    lpn->fsn ^= 1;  /* Toggle between 0 and 1 */
}

/* Increment LPNCounter before each Friend Request */
void lpn_send_friend_request(struct lpn_state *lpn)
{
    uint16_t counter = lpn->lpn_counter;
    /* mesh_send_friend_request(counter); */
    lpn->lpn_counter++;  /* wraps at 0xFFFF -> 0x0000 */
}

Once friendship is established, the LPN doesn’t passively listen — it actively asks. This is the Friend Poll → Friend Update/Message cycle. The LPN wakes up periodically, sends a Friend Poll, and the Friend replies with whatever is queued.

The MD (More Data) bit in Friend Update is the key signal. As long as MD=1, the LPN keeps polling. When it sees MD=0, the queue is empty and the LPN can go back to sleep.

The FSN (Friend Sequence Number) is a single bit (0 or 1) that toggles on every successful exchange. If the LPN gets a duplicate response (same PDU as last time), it does NOT toggle FSN — this acts as a simple duplicate-detection mechanism.

Timing Parameters You Must Know

If the LPN doesn’t poll before PollTimeout expires, the friendship is automatically terminated. The LPN then has to go through establishment again.

The Friend node needs to know which group addresses or virtual addresses to watch on behalf of the LPN. Without this, it would miss mesh messages sent to groups the LPN belongs to.

The LPN manages this via two messages:

Each Add or Remove message carries a TransactionNumber (starts at 0x00, increments for each new request). The Confirm message echoes this number back so the LPN can verify the Friend processed the right request.

/* Pseudocode: LPN subscription management via BlueZ mesh D-Bus
 * Real API: org.bluez.mesh.Node1 → AddAppKey, etc.
 * For subscription list updates, the mesh app layer sends
 * Friend Subscription List Add/Remove via the transport layer.
 */

struct subscription_msg {
    uint8_t  transaction_number;   /* increments per new request */
    uint16_t addresses[10];        /* group/virtual addresses */
    uint8_t  address_count;
};

void lpn_add_subscription(struct lpn_state *lpn,
                           uint16_t group_addr)
{
    struct subscription_msg msg = {
        .transaction_number = lpn->txn_number++,
        .addresses          = { group_addr },
        .address_count      = 1,
    };

    /* Send Friend Subscription List Add, then wait for Confirm */
    /* mesh_send_friend_sub_add(&msg); */
}

void lpn_remove_subscription(struct lpn_state *lpn,
                              uint16_t group_addr)
{
    struct subscription_msg msg = {
        .transaction_number = lpn->txn_number++,
        .addresses          = { group_addr },
        .address_count      = 1,
    };

    /* Send Friend Subscription List Remove */
    /* mesh_send_friend_sub_remove(&msg); */
}

Normal mesh nodes handle reassembly of segmented messages themselves. For a Low Power Node, this is different — the LPN can’t stay awake long enough to collect all segments in real time.

So the Friend node takes over reassembly. Here’s what happens:

The Friend node acts as a proxy — it reassembles the segmented message on behalf of the LPN and sends segment acknowledgments back to the original sender. The LPN never deals with individual segments directly; it always gets a complete, reassembled message from its Friend.

Friendship can end in two ways:

After friendship ends, if the LPN still needs to receive mesh messages, it must restart the establishment process from scratch — new Friend Request, new LPNCounter value, new security material.