1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
// Copyright (c) 2025-2026 (r)evolve - Revolve Team LLC
// SPDX-License-Identifier: Apache-2.0
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//! 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
//!
//! ```text
//! ┌─────────────────────────────────────────────────────────┐
//! │ MeshManager │
//! │ ┌─────────────┐ ┌─────────────┐ ┌─────────────────┐ │
//! │ │ Topology │ │ Router │ │ Parent Failover │ │
//! │ │ State │ │ │ │ │ │
//! │ └─────────────┘ └─────────────┘ └─────────────────┘ │
//! └─────────────────────────────────────────────────────────┘
//! │
//! ▼
//! ┌──────────────────────────────┐
//! │ TopologyEvents │
//! │ • ParentConnected │
//! │ • ChildConnected │
//! │ • TopologyChanged │
//! └──────────────────────────────┘
//! ```
//!
//! ## Usage
//!
//! ```ignore
//! 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
//!
//! ```ignore
//! 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);
//! }
//! }
//! ```
pub use ;
pub use ;
pub use ;