qualia_core_db/net/acoustic_ble_mesh/
acoustic.rs

1//! Acoustic network: nodes, channels, modem/PHY, and the acoustic protocol stack
2//! (physical / data-link / network / transport layers) for through-wall and
3//! underwater communication.
4
5use super::*;
6
7/// Acoustic network for underwater/through-wall communication
8pub struct AcousticNetwork {
9    nodes: HashMap<String, AcousticNode>,
10    channel_manager: AcousticChannelManager,
11    modem_controller: AcousticModemController,
12    protocol_handler: AcousticProtocolHandler,
13}
14
15/// Acoustic node in the network
16#[derive(Debug, Clone)]
17pub struct AcousticNode {
18    pub node_id: String,
19    pub node_type: NodeType,
20    pub capabilities: AcousticCapabilities,
21    pub location: Option<Location>,
22    pub status: NodeStatus,
23    pub signal_strength: f64,
24    pub battery_level: f64,
25}
26
27/// Acoustic capabilities
28#[derive(Debug, Clone, Serialize, Deserialize)]
29pub struct AcousticCapabilities {
30    pub frequency_range: (f64, f64), // Hz
31    pub bandwidth: f64,              // Hz
32    pub max_range: f64,              // meters
33    pub data_rate: f64,              // bps
34    pub modulation: ModulationType,
35    pub error_correction: ErrorCorrectionType,
36}
37
38/// Modulation types
39#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
40pub enum ModulationType {
41    FSK,
42    PSK,
43    OFDM,
44    DSSS,
45    Chirp,
46}
47
48/// Error correction types
49#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
50pub enum ErrorCorrectionType {
51    None,
52    Hamming,
53    ReedSolomon,
54    Convolutional,
55    LDPC,
56}
57
58/// Node status
59#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
60pub enum NodeStatus {
61    Active,
62    Idle,
63    Sleeping,
64    Error,
65    Offline,
66}
67
68/// Acoustic channel manager
69pub struct AcousticChannelManager {
70    available_channels: Vec<AcousticChannel>,
71    active_channels: HashMap<String, AcousticChannel>,
72    channel_allocation: ChannelAllocationStrategy,
73}
74
75/// Acoustic channel
76#[derive(Debug, Clone)]
77pub struct AcousticChannel {
78    pub channel_id: String,
79    pub frequency: f64,
80    pub bandwidth: f64,
81    pub power_level: f64,
82    pub modulation: ModulationType,
83    pub noise_floor: f64,
84    pub interference_level: f64,
85}
86
87/// Channel allocation strategies
88#[derive(Debug, Clone, PartialEq)]
89pub enum ChannelAllocationStrategy {
90    Fixed,
91    Dynamic,
92    Adaptive,
93    Opportunistic,
94}
95
96/// Acoustic modem controller
97pub struct AcousticModemController {
98    modem_type: ModemType,
99    transmission_power: f64,
100    receiver_sensitivity: f64,
101    signal_processing: SignalProcessingConfig,
102}
103
104/// Modem types
105#[derive(Debug, Clone, PartialEq)]
106pub enum ModemType {
107    SoftwareDefined,
108    HardwareBased,
109    Hybrid,
110}
111
112/// Signal processing configuration
113#[derive(Debug, Clone)]
114pub struct SignalProcessingConfig {
115    pub sampling_rate: f64,
116    pub fft_size: usize,
117    pub filter_type: FilterType,
118    pub noise_reduction: bool,
119    pub equalization: bool,
120}
121
122/// Filter types
123#[derive(Debug, Clone, PartialEq)]
124pub enum FilterType {
125    LowPass,
126    HighPass,
127    BandPass,
128    Notch,
129    Adaptive,
130}
131
132/// Packet handler
133pub struct PacketHandler {}
134
135/// Flow control
136pub struct FlowControl {}
137
138/// Error handling
139pub struct ErrorHandling {}
140
141/// Acoustic protocol handler
142pub struct AcousticProtocolHandler {
143    protocol_stack: AcousticProtocolStack,
144    packet_handler: PacketHandler,
145    flow_control: FlowControl,
146    error_handling: ErrorHandling,
147}
148
149/// Acoustic protocol stack
150#[derive(Debug, Clone)]
151pub struct AcousticProtocolStack {
152    pub physical_layer: PhysicalLayer,
153    pub data_link_layer: DataLinkLayer,
154    pub network_layer: NetworkLayer,
155    pub transport_layer: TransportLayer,
156}
157
158/// Physical layer
159#[derive(Debug, Clone)]
160pub struct PhysicalLayer {
161    pub modulation: ModulationType,
162    pub coding: ErrorCorrectionType,
163    pub frequency_hopping: bool,
164    pub power_control: bool,
165}
166
167/// Data link layer
168#[derive(Debug, Clone)]
169pub struct DataLinkLayer {
170    pub mac_protocol: MacProtocol,
171    pub frame_format: FrameFormat,
172    pub error_detection: ErrorDetection,
173    pub retransmission: RetransmissionStrategy,
174}
175
176/// MAC protocols
177#[derive(Debug, Clone, PartialEq)]
178pub enum MacProtocol {
179    CSMA,
180    TDMA,
181    FDMA,
182    CDMA,
183    Hybrid,
184}
185
186/// Frame formats
187#[derive(Debug, Clone, PartialEq)]
188pub enum FrameFormat {
189    Fixed,
190    Variable,
191    Adaptive,
192}
193
194/// Error detection
195#[derive(Debug, Clone, PartialEq)]
196pub enum ErrorDetection {
197    CRC,
198    Checksum,
199    Parity,
200    None,
201}
202
203/// Retransmission strategies
204#[derive(Debug, Clone, PartialEq)]
205pub enum RetransmissionStrategy {
206    StopAndWait,
207    GoBackN,
208    SelectiveRepeat,
209    Adaptive,
210}
211
212/// Network layer
213#[derive(Debug, Clone)]
214pub struct NetworkLayer {
215    pub routing_protocol: RoutingProtocol,
216    pub addressing_scheme: AddressingScheme,
217    pub fragmentation: bool,
218    pub congestion_control: bool,
219}
220
221/// Routing protocols
222#[derive(Debug, Clone, PartialEq)]
223pub enum RoutingProtocol {
224    Flooding,
225    DistanceVector,
226    LinkState,
227    Geographic,
228    Opportunistic,
229}
230
231/// Addressing schemes
232#[derive(Debug, Clone, PartialEq)]
233pub enum AddressingScheme {
234    Hierarchical,
235    Flat,
236    Geographic,
237    ContentBased,
238}
239
240/// Transport layer
241#[derive(Debug, Clone)]
242pub struct TransportLayer {
243    pub transport_protocol: TransportProtocol,
244    pub reliability: ReliabilityLevel,
245    pub flow_control: FlowControlType,
246    pub congestion_control: CongestionControlType,
247}
248
249/// Transport protocols
250#[derive(Debug, Clone, PartialEq)]
251pub enum TransportProtocol {
252    UDP,
253    TCP,
254    DTN,
255    Custom,
256}
257
258/// Reliability levels
259#[derive(Debug, Clone, PartialEq)]
260pub enum ReliabilityLevel {
261    BestEffort,
262    Reliable,
263    SemiReliable,
264    Adaptive,
265}
266
267/// Flow control types
268#[derive(Debug, Clone, PartialEq)]
269pub enum FlowControlType {
270    None,
271    WindowBased,
272    RateBased,
273    CreditBased,
274}
275
276/// Congestion control types
277#[derive(Debug, Clone, PartialEq)]
278pub enum CongestionControlType {
279    None,
280    AIMD,
281    RED,
282    Custom,
283}
284
285impl AcousticNetwork {
286    pub fn new() -> Self {
287        Self {
288            nodes: HashMap::new(),
289            channel_manager: AcousticChannelManager::new(),
290            modem_controller: AcousticModemController::new(),
291            protocol_handler: AcousticProtocolHandler::new(),
292        }
293    }
294
295    pub fn initialize(&mut self) -> Result<(), MeshError> {
296        // Initialize acoustic network components
297        self.channel_manager.initialize()?;
298        self.modem_controller.initialize()?;
299        self.protocol_handler.initialize()?;
300        Ok(())
301    }
302
303    pub fn discover_nodes(&mut self) -> Result<Vec<AcousticNode>, MeshError> {
304        let mut discovered_nodes = Vec::new();
305
306        // Simulate node discovery
307        for i in 0..5 {
308            let node = AcousticNode {
309                node_id: format!("acoustic_node_{}", i),
310                node_type: NodeType::Sensor,
311                capabilities: AcousticCapabilities {
312                    frequency_range: (20000.0, 50000.0), // 20-50 kHz
313                    bandwidth: 1000.0,                   // 1 kHz
314                    max_range: 1000.0,                   // 1 km
315                    data_rate: 1000.0,                   // 1 kbps
316                    modulation: ModulationType::FSK,
317                    error_correction: ErrorCorrectionType::ReedSolomon,
318                },
319                location: Some(Location {
320                    latitude: 37.7749 + (i as f64 * 0.01),
321                    longitude: -122.4194 + (i as f64 * 0.01),
322                    altitude: Some(100.0),
323                    accuracy: 10.0,
324                }),
325                status: NodeStatus::Active,
326                signal_strength: -50.0 + (i as f64 * 5.0),
327                battery_level: 100.0 - (i as f64 * 10.0),
328            };
329
330            self.nodes.insert(node.node_id.clone(), node.clone());
331            discovered_nodes.push(node);
332        }
333
334        Ok(discovered_nodes)
335    }
336
337    pub fn send_message(&mut self, _message: &StoredMessage) -> Result<(), MeshError> {
338        // Send message through acoustic network
339        thread::sleep(Duration::from_millis(500)); // Simulate transmission time
340        Ok(())
341    }
342
343    pub fn send_payload(
344        &mut self,
345        _destination: &str,
346        _payload: &[u8],
347        _priority: MessagePriority,
348    ) -> Result<(), MeshError> {
349        thread::sleep(Duration::from_millis(500));
350        Ok(())
351    }
352
353    pub fn get_node_count(&self) -> u32 {
354        self.nodes.len() as u32
355    }
356
357    pub fn optimize_discovery(&mut self) -> Result<(), MeshError> {
358        // Optimize acoustic discovery
359        Ok(())
360    }
361}
362
363impl AcousticChannelManager {
364    pub fn new() -> Self {
365        Self {
366            available_channels: Vec::new(),
367            active_channels: HashMap::new(),
368            channel_allocation: ChannelAllocationStrategy::Adaptive,
369        }
370    }
371
372    pub fn initialize(&mut self) -> Result<(), MeshError> {
373        // Pre-allocate standard acoustic channels (20-50 kHz range).
374        for i in 0..5 {
375            let freq = 20000.0 + i as f64 * 6000.0;
376            self.available_channels.push(AcousticChannel {
377                channel_id: format!("acoustic_ch_{}", i),
378                frequency: freq,
379                bandwidth: 1000.0,
380                power_level: 100.0,
381                modulation: ModulationType::FSK,
382                noise_floor: -80.0,
383                interference_level: 0.0,
384            });
385        }
386        Ok(())
387    }
388
389    pub fn allocate_channel(&mut self, channel_id: &str) -> Option<&AcousticChannel> {
390        if let Some(pos) = self
391            .available_channels
392            .iter()
393            .position(|c| c.channel_id == channel_id)
394        {
395            let channel = self.available_channels.remove(pos);
396            self.active_channels
397                .insert(channel.channel_id.clone(), channel);
398        }
399        self.active_channels.get(channel_id)
400    }
401
402    pub fn release_channel(&mut self, channel_id: &str) {
403        if let Some(channel) = self.active_channels.remove(channel_id) {
404            self.available_channels.push(channel);
405        }
406    }
407
408    pub fn available_channel_count(&self) -> usize {
409        self.available_channels.len()
410    }
411
412    pub fn active_channel_count(&self) -> usize {
413        self.active_channels.len()
414    }
415
416    pub fn allocation_strategy(&self) -> &ChannelAllocationStrategy {
417        &self.channel_allocation
418    }
419}
420
421impl AcousticModemController {
422    pub fn new() -> Self {
423        Self {
424            modem_type: ModemType::SoftwareDefined,
425            transmission_power: 100.0,    // 100W
426            receiver_sensitivity: -120.0, // -120dBm
427            signal_processing: SignalProcessingConfig {
428                sampling_rate: 192000.0, // 192 kHz
429                fft_size: 1024,
430                filter_type: FilterType::BandPass,
431                noise_reduction: true,
432                equalization: true,
433            },
434        }
435    }
436
437    pub fn initialize(&mut self) -> Result<(), MeshError> {
438        Ok(())
439    }
440
441    pub fn modem_type(&self) -> &ModemType {
442        &self.modem_type
443    }
444
445    pub fn transmission_power(&self) -> f64 {
446        self.transmission_power
447    }
448
449    pub fn set_transmission_power(&mut self, power: f64) {
450        self.transmission_power = power.max(0.0);
451    }
452
453    pub fn receiver_sensitivity(&self) -> f64 {
454        self.receiver_sensitivity
455    }
456
457    pub fn signal_processing(&self) -> &SignalProcessingConfig {
458        &self.signal_processing
459    }
460
461    /// Estimate maximum communication range based on transmission power,
462    /// receiver sensitivity, and acoustic spreading loss (15 dB/km).
463    pub fn estimated_range_km(&self) -> f64 {
464        let snr_margin = self.transmission_power + self.receiver_sensitivity.abs();
465        snr_margin / 15.0
466    }
467}
468
469impl AcousticProtocolHandler {
470    pub fn new() -> Self {
471        Self {
472            protocol_stack: AcousticProtocolStack::new(),
473            packet_handler: PacketHandler::new(),
474            flow_control: FlowControl::new(),
475            error_handling: ErrorHandling::new(),
476        }
477    }
478
479    pub fn initialize(&mut self) -> Result<(), MeshError> {
480        Ok(())
481    }
482
483    pub fn protocol_stack(&self) -> &AcousticProtocolStack {
484        &self.protocol_stack
485    }
486
487    pub fn packet_handler(&self) -> &PacketHandler {
488        &self.packet_handler
489    }
490
491    pub fn flow_control(&self) -> &FlowControl {
492        &self.flow_control
493    }
494
495    pub fn error_handling(&self) -> &ErrorHandling {
496        &self.error_handling
497    }
498}
499
500impl AcousticProtocolStack {
501    pub fn new() -> Self {
502        Self {
503            physical_layer: PhysicalLayer::new(),
504            data_link_layer: DataLinkLayer::new(),
505            network_layer: NetworkLayer::new(),
506            transport_layer: TransportLayer::new(),
507        }
508    }
509}
510
511impl PhysicalLayer {
512    pub fn new() -> Self {
513        Self {
514            modulation: ModulationType::FSK,
515            coding: ErrorCorrectionType::ReedSolomon,
516            frequency_hopping: true,
517            power_control: true,
518        }
519    }
520}
521
522impl DataLinkLayer {
523    pub fn new() -> Self {
524        Self {
525            mac_protocol: MacProtocol::CSMA,
526            frame_format: FrameFormat::Adaptive,
527            error_detection: ErrorDetection::CRC,
528            retransmission: RetransmissionStrategy::Adaptive,
529        }
530    }
531}
532
533impl NetworkLayer {
534    pub fn new() -> Self {
535        Self {
536            routing_protocol: RoutingProtocol::Geographic,
537            addressing_scheme: AddressingScheme::Geographic,
538            fragmentation: true,
539            congestion_control: true,
540        }
541    }
542}
543
544impl TransportLayer {
545    pub fn new() -> Self {
546        Self {
547            transport_protocol: TransportProtocol::DTN,
548            reliability: ReliabilityLevel::SemiReliable,
549            flow_control: FlowControlType::CreditBased,
550            congestion_control: CongestionControlType::RED,
551        }
552    }
553}
554
555impl PacketHandler {
556    pub fn new() -> Self {
557        Self {}
558    }
559}
560
561impl FlowControl {
562    pub fn new() -> Self {
563        Self {}
564    }
565}
566
567impl ErrorHandling {
568    pub fn new() -> Self {
569        Self {}
570    }
571}
qualia_core_db/net/acoustic_ble_mesh/acoustic.rs

qualia_core_db/net/acoustic_ble_mesh/
acoustic.rs
