Module mesh 

Mesh Topology Management

This module provides mesh topology management for PEAT-BTLE, including:

• Topology tracking: Parent/child/peer relationships
• Connection management: Connect, disconnect, failover
• Message routing: Upward aggregation, downward dissemination
• RSSI-based selection: Best parent/peer selection

Architecture

┌─────────────────────────────────────────────────────────┐
│                    MeshManager                           │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────┐  │
│  │  Topology   │  │   Router    │  │  Parent Failover │  │
│  │   State     │  │             │  │                  │  │
│  └─────────────┘  └─────────────┘  └─────────────────┘  │
└─────────────────────────────────────────────────────────┘
                         │
                         ▼
           ┌──────────────────────────────┐
           │     TopologyEvents           │
           │  • ParentConnected           │
           │  • ChildConnected            │
           │  • TopologyChanged           │
           └──────────────────────────────┘

Usage

use peat_btle::mesh::{MeshManager, TopologyConfig, TopologyEvent};
use peat_btle::{NodeId, HierarchyLevel};

// Create mesh manager
let manager = MeshManager::new(
    NodeId::new(0x12345678),
    HierarchyLevel::Platform,
    TopologyConfig::default(),
);

// Register for topology events
manager.on_topology_event(Box::new(|event| {
    match event {
        TopologyEvent::ParentConnected { node_id, .. } => {
            println!("Connected to parent: {}", node_id);
        }
        _ => {}
    }
}));

// Start the manager
manager.start()?;

// Process discovered beacons
manager.process_beacon(&beacon, rssi);

// Select and connect to best parent
if let Some(candidate) = manager.select_best_parent() {
    manager.connect_parent(candidate.node_id, candidate.level, candidate.rssi)?;
}

Parent Failover

When parent connection is lost:

1. start_failover() is called
2. Manager enters Failover state
3. ParentFailoverStarted event is emitted
4. Application scans for new parent candidates
5. complete_failover() connects to new parent (or gives up)
6. ParentFailoverCompleted event is emitted

Message Routing

The MeshRouter provides routing decisions:

• Upward: To parent (aggregation)
• Downward: To children (dissemination)
• Broadcast: To all connected peers
• Targeted: To a specific node

use peat_btle::mesh::{MeshRouter, RouteDirection};

let router = MeshRouter::new(node_id, my_level);
let topology = manager.topology();

let decision = router.route(RouteDirection::Upward, &topology);
if decision.routed {
    for next_hop in decision.next_hops {
        send_to(&next_hop, &message);
    }
}

Structs

HopTracker

Message hop tracking for loop prevention

MeshManager

Manages the BLE mesh topology

MeshRouter

Router for mesh messages

MeshTopology

Current mesh topology state

ParentCandidate

Candidate for parent selection

PeerInfo

Information about a peer in the mesh

RouteDecision

A routing decision for a message

TopologyConfig

Configuration for topology management

Enums

ConnectionState

State of a connection to a peer

DisconnectReason

Reason for a disconnection

ManagerState

Mesh manager state

PeerRole

Role of a peer in the mesh topology

RouteDirection

Message routing direction

RouteFailure

Reason for routing failure

TopologyEvent

Events that occur when the mesh topology changes

Type Aliases

TopologyCallback

Callback type for topology events