Implementing a BLE Mesh for Distributed Load Balancing in Rafavi Super Charging Piles

Implementing a BLE Mesh for Distributed Load Balancing in Rafavi Super Charging Piles

The proliferation of electric vehicles (EVs) demands an equally robust and intelligent charging infrastructure. Rafavi Super Charging Piles, designed for high-power delivery in dense urban environments, face a critical challenge: how to manage peak loads without overloading the local grid or sacrificing user experience. Traditional centralized load balancing systems introduce a single point of failure and suffer from latency as the number of charging piles scales. This article explores a distributed solution leveraging Bluetooth Low Energy (BLE) Mesh networking to achieve real-time, peer-to-peer load balancing among Rafavi charging piles.

Why BLE Mesh for Charging Infrastructure?

BLE, as defined in the Bluetooth Core Specification, is a short-range wireless technology optimized for low power consumption and low data rate applications. While a single BLE connection is point-to-point, the BLE Mesh profile (introduced in the Mesh Model specification) enables many-to-many (m:n) communication. This is ideal for a distributed system of charging piles where each node must broadcast its state and receive commands from its neighbors.

The key advantages of BLE Mesh for this application are:

• Decentralization: No central controller is required. Each pile makes load-balancing decisions based on local information and messages from adjacent piles.
• Self-Healing: If one pile fails or a communication link is lost, messages are automatically rerouted through other nodes in the mesh.
• Scalability: The mesh can easily scale to hundreds of piles without a proportional increase in infrastructure complexity.
• Low Power: BLE is inherently low-power, which is crucial for the embedded microcontrollers (MCUs) inside the piles that must remain active even when not charging.

System Architecture and Protocol Design

Each Rafavi Super Charging Pile is equipped with a BLE 5.x module (e.g., nRF52840 or similar) running a BLE Mesh stack. The pile’s main MCU communicates with the BLE module over UART or SPI, exchanging a custom protocol for load balancing.

The system uses a publish-subscribe model over BLE Mesh. Each pile subscribes to a specific group address for load-balancing commands and publishes its own status to that same group. The core states for a pile are:

• NODE_ID: A unique 16-bit identifier for the pile.
• MAX_POWER: The maximum power the pile can deliver (e.g., 350 kW).
• CURRENT_DRAW: The real-time power being drawn by the connected EV.
• AVAILABLE_POWER: MAX_POWER - CURRENT_DRAW.
• PRIORITY: A configurable priority (e.g., 1-10, where 1 is highest). This can be based on user subscription, time-of-day, or emergency vehicle status.
• LOAD_SHARE_FACTOR: A calculated value representing how much of the total available power this pile should receive.

The protocol defines two primary messages:

1. STATUS_ADVERTISEMENT (Unacknowledged): Sent periodically (e.g., every 5 seconds) by each pile. Contains NODE_ID, CURRENT_DRAW, AVAILABLE_POWER, and PRIORITY.
2. LOAD_BALANCE_COMMAND (Acknowledged): Sent by a pile to its neighbors when it detects an overload or underload condition. Contains the target NODE_ID and a new CURRENT_DRAW limit.

Distributed Load Balancing Algorithm

The core algorithm is a distributed consensus mechanism. It does not rely on a single leader but on local optimization through message exchange. The algorithm runs on each pile’s MCU.

Step 1: Local State Collection
Each pile maintains a local table of its neighbors' statuses, updated via STATUS_ADVERTISEMENT messages. The table includes fields like neighbor_id, last_seen, available_power, and priority.

Step 2: Overload Detection
A pile is considered overloaded if CURRENT_DRAW > (0.9 * MAX_POWER) for more than 10 seconds. It then calculates the excess power needed: excess = CURRENT_DRAW - (0.8 * MAX_POWER).

Step 3: Distributed Power Redistribution
The overloaded pile sends a LOAD_BALANCE_COMMAND to the neighbor with the highest AVAILABLE_POWER and the lowest PRIORITY (i.e., most flexible). The command requests a reduction in the neighbor's CURRENT_DRAW by excess kW.

The receiving pile evaluates the request. If it can accommodate the reduction (i.e., its own AVAILABLE_POWER is sufficient), it reduces its own output and sends an acknowledgment. If not, it forwards the request to its own neighbors (propagation). This is a form of constrained flooding limited by a Time-To-Live (TTL) value of 2 hops to prevent network congestion.

Step 4: Underload Balancing
Conversely, if a pile is underloaded (e.g., CURRENT_DRAW < 0.2 * MAX_POWER for 30 seconds), it can offer its spare capacity to the mesh. It broadcasts a CAPACITY_OFFER message. Neighbors with higher priority loads can then request a transfer of power.

Code Example: BLE Mesh Status Advertisement Handler

The following C-like pseudocode demonstrates the handler on a Rafavi pile’s MCU when a STATUS_ADVERTISEMENT message is received from a neighbor.

// Structure for neighbor state
typedef struct {
    uint16_t node_id;
    uint32_t max_power;       // in watts
    uint32_t current_draw;    // in watts
    uint32_t available_power; // in watts
    uint8_t  priority;
    uint32_t last_seen;       // system ticks
} neighbor_state_t;

// Global neighbor table (simplified)
neighbor_state_t neighbor_table[MAX_NEIGHBORS];
uint8_t neighbor_count = 0;

// BLE Mesh message callback
void on_status_advertisement(uint16_t src_addr, uint8_t *data, uint8_t len) {
    if (len < sizeof(neighbor_state_t)) return;

    neighbor_state_t *msg = (neighbor_state_t *)data;

    // Find or add neighbor in local table
    int idx = find_neighbor_by_id(msg->node_id);
    if (idx == -1) {
        if (neighbor_count >= MAX_NEIGHBORS) return; // table full
        idx = neighbor_count++;
    }

    // Update entry
    memcpy(&neighbor_table[idx], msg, sizeof(neighbor_state_t));
    neighbor_table[idx].last_seen = get_system_ticks();

    // Check if this neighbor is overloaded
    if (neighbor_table[idx].current_draw > (0.9 * neighbor_table[idx].max_power)) {
        // Trigger local load balancing logic
        handle_overload_condition(idx);
    }
}

void handle_overload_condition(uint8_t neighbor_idx) {
    // Calculate excess power needed
    uint32_t excess = neighbor_table[neighbor_idx].current_draw - 
                      (0.8 * neighbor_table[neighbor_idx].max_power);

    // Find the best candidate to offload to (highest available, lowest priority)
    int best_candidate = -1;
    uint32_t best_available = 0;
    uint8_t best_priority = 255;

    for (int i = 0; i < neighbor_count; i++) {
        if (i == neighbor_idx) continue;
        if (neighbor_table[i].available_power > best_available ||
            (neighbor_table[i].available_power == best_available && 
             neighbor_table[i].priority < best_priority)) {
            best_available = neighbor_table[i].available_power;
            best_priority = neighbor_table[i].priority;
            best_candidate = i;
        }
    }

    if (best_candidate != -1 && best_available >= excess) {
        // Send LOAD_BALANCE_COMMAND to the candidate
        send_load_balance_command(neighbor_table[best_candidate].node_id, excess);
    } else {
        // No suitable neighbor; propagate the request via TTL-limited flood
        send_load_balance_request(excess, TTL_2_HOPS);
    }
}

Performance Analysis and Considerations

The effectiveness of this system depends on network latency, message reliability, and the quality of the BLE Mesh stack.

• Latency: The BLE Mesh specification defines a maximum latency for acknowledged messages (typically under 100 ms for a few hops). For load balancing, a reaction time of 2-5 seconds is acceptable, making BLE Mesh suitable. The STATUS_ADVERTISEMENT interval (e.g., 5 seconds) creates a trade-off: shorter intervals provide fresher data but increase network traffic.
• Reliability: BLE Mesh uses a store-and-forward mechanism and message acknowledgment for critical commands. However, in dense deployments (e.g., 100+ piles in a parking lot), message collisions can occur. To mitigate this, we implement a random backoff before retransmission and use a network key to secure all messages.
• Power Consumption: The BLE module on each pile must be active to receive and forward messages. Using a 5-second advertising interval and a 100-ms scanning window, the average current consumption of the BLE module is approximately 1-2 mA (for a typical nRF52840). This is negligible compared to the pile’s main power electronics.
• Scalability: The BLE Mesh specification supports up to 32,767 nodes. For a Rafavi installation with 50-200 piles, the mesh is well within limits. However, the STATUS_ADVERTISEMENT message size (approximately 20 bytes) and the number of neighbors (typically 4-8 in a 2D grid) keep the network load low.

Integration with UWB for Precision Positioning

While BLE handles the data communication for load balancing, UWB (Ultra-Wideband) radar technology, as detailed in the referenced research paper, can be integrated to provide precise location awareness. The paper highlights UWB’s advantages in “high-precision positioning” and “penetration” capabilities. In a Rafavi charging station, UWB modules on each pile can:

• Determine the exact position of an approaching EV (within 10 cm accuracy).
• Allow the BLE Mesh to pre-allocate power to the pile closest to the arriving vehicle.
• Enable dynamic grouping of piles for parallel charging (e.g., two piles sharing a 350 kW load).

The UWB radar chip can act as a sensor input to the BLE Mesh system. When a vehicle is detected by UWB, the mesh can proactively adjust load distribution before the vehicle even connects.

Conclusion

Implementing a BLE Mesh network for distributed load balancing in Rafavi Super Charging Piles offers a robust, scalable, and cost-effective solution. By moving away from a centralized controller and leveraging the self-healing properties of a mesh, we achieve high availability and real-time responsiveness. The integration of UWB positioning further enhances the system’s intelligence, allowing for proactive load management. This architecture not only solves the immediate challenge of grid overload but also future-proofs the charging infrastructure for the next generation of high-power EVs.

💬 欢迎到论坛参与讨论： 点击这里分享您的见解或提问