ush 0.1.0

Ultrasonic Shell - communicate between devices using ultrasonic sound waves
Documentation 
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325

use ush::audio::AudioConfig;
use ush::modulation::{FskModulator, FskDemodulator, ModulationConfig};
use ush::protocol::{ProtocolEncoder, ProtocolDecoder, Message};
use ush::{UshError, UshResult};

#[tokio::test]
async fn test_full_pipeline() -> UshResult<()> {
    // Test the complete pipeline: text -> protocol -> modulation -> audio -> demodulation -> protocol -> text
    
    let modulation_config = ModulationConfig::default();
    let modulator = FskModulator::new(modulation_config.clone());
    let demodulator = FskDemodulator::new(modulation_config);
    
    let mut encoder = ProtocolEncoder::new();
    let mut decoder = ProtocolDecoder::new();
    
    let original_text = "Hello, ultrasonic world! 🌊";
    
    // Encode text to protocol frame
    let frame_data = encoder.encode_text(original_text)?;
    
    // Modulate frame to audio samples
    let audio_samples = modulator.encode_bytes(&frame_data);
    
    // Demodulate audio back to bytes
    let decoded_frame_data = demodulator.decode_bytes(&audio_samples)?;
    
    // Decode protocol frame back to messages
    let messages = decoder.feed_data(&decoded_frame_data);
    
    assert!(!messages.is_empty(), "No messages decoded");
    
    let decoded_text = messages[0].get_text()?;
    assert_eq!(original_text, decoded_text);
    
    println!("✓ Full pipeline test passed: \"{}\"", decoded_text);
    Ok(())
}

#[tokio::test] 
async fn test_multiple_messages() -> UshResult<()> {
    let modulation_config = ModulationConfig::default();
    let modulator = FskModulator::new(modulation_config.clone());
    let demodulator = FskDemodulator::new(modulation_config);
    
    let mut encoder = ProtocolEncoder::new();
    let mut decoder = ProtocolDecoder::new();
    
    let messages = vec![
        "First message",
        "Second message with numbers: 12345",
        "Third message with symbols: @#$%^&*()",
    ];
    
    // Test each message individually (since silence breaks symbol alignment)
    let mut decoded_messages = Vec::new();
    
    for message in &messages {
        let frame_data = encoder.encode_text(message)?;
        let samples = modulator.encode_bytes(&frame_data);
        let decoded_bytes = demodulator.decode_bytes(&samples)?;
        let messages_decoded = decoder.feed_data(&decoded_bytes);
        decoded_messages.extend(messages_decoded);
    }
    
    assert_eq!(messages.len(), decoded_messages.len(), "Message count mismatch");
    
    for (i, decoded_msg) in decoded_messages.iter().enumerate() {
        let decoded_text = decoded_msg.get_text()?;
        assert_eq!(messages[i], decoded_text, "Message {} mismatch", i);
        println!("✓ Message {}: \"{}\"", i + 1, decoded_text);
    }
    
    Ok(())
}

#[tokio::test]
async fn test_noisy_environment() -> UshResult<()> {
    let modulation_config = ModulationConfig::default();
    let modulator = FskModulator::new(modulation_config.clone());
    let demodulator = FskDemodulator::new(modulation_config);
    
    let mut encoder = ProtocolEncoder::new();
    let mut decoder = ProtocolDecoder::new();
    
    let test_message = "Noise test message";
    let frame_data = encoder.encode_text(test_message)?;
    let mut audio_samples = modulator.encode_bytes(&frame_data);
    
    // Add white noise
    use std::f32::consts::PI;
    let noise_level = 0.05; // 5% noise
    for (i, sample) in audio_samples.iter_mut().enumerate() {
        let noise = ((i as f32 * 0.1).sin() + (i as f32 * 0.17).cos()) * noise_level;
        *sample += noise;
    }
    
    // Try to decode with noise
    let decoded_bytes = demodulator.decode_bytes(&audio_samples);
    
    match decoded_bytes {
        Ok(bytes) => {
            let messages = decoder.feed_data(&bytes);
            if !messages.is_empty() {
                let decoded_text = messages[0].get_text()?;
                if decoded_text == test_message {
                    println!("✓ Successfully decoded despite noise: \"{}\"", decoded_text);
                } else {
                    println!("âš  Decoded with errors: \"{}\" (expected: \"{}\")", decoded_text, test_message);
                }
            } else {
                println!("âš  No messages decoded from noisy signal");
            }
        }
        Err(e) => {
            println!("âš  Failed to decode noisy signal: {}", e);
            // This is acceptable for noise testing
        }
    }
    
    Ok(())
}

#[tokio::test]
async fn test_different_message_lengths() -> UshResult<()> {
    let modulation_config = ModulationConfig::default();
    let modulator = FskModulator::new(modulation_config.clone());
    let demodulator = FskDemodulator::new(modulation_config);
    
    let mut encoder = ProtocolEncoder::new();
    let mut decoder = ProtocolDecoder::new();
    
    let test_messages = vec![
        "A", // Very short
        "Hello", // Short
        "This is a medium-length message for testing purposes.", // Medium
        "This is a very long message that contains many words and should test the system's ability to handle longer text transmissions. It includes various characters like numbers 123456789 and symbols !@#$%^&*()_+-=[]{}|;:,.<>? to ensure comprehensive testing coverage.", // Long
    ];
    
    for (i, message) in test_messages.iter().enumerate() {
        let frame_data = encoder.encode_text(message)?;
        let samples = modulator.encode_bytes(&frame_data);
        
        let decoded_bytes = demodulator.decode_bytes(&samples)?;
        let messages = decoder.feed_data(&decoded_bytes);
        
        assert!(!messages.is_empty(), "No messages decoded for test {}", i);
        let decoded_text = messages[0].get_text()?;
        assert_eq!(*message, decoded_text, "Message {} length test failed", i);
        
        println!("✓ Length test {}: {} chars -> {} samples", 
                 i + 1, message.len(), samples.len());
    }
    
    Ok(())
}

#[tokio::test]
async fn test_frequency_separation() -> UshResult<()> {
    // Test different frequency configurations
    let configs = vec![
        (17000.0, 19000.0), // Wide separation
        (18500.0, 19500.0), // Narrow separation  
        (19000.0, 21000.0), // High frequencies
    ];
    
    let test_message = "Frequency test";
    
    for (i, (freq_0, freq_1)) in configs.iter().enumerate() {
        let modulation_config = ModulationConfig {
            sample_rate: 44100,
            freq_0: *freq_0,
            freq_1: *freq_1,
            symbol_duration: 0.01,
            ramp_duration: 0.002,
        };
        
        let modulator = FskModulator::new(modulation_config.clone());
        let demodulator = FskDemodulator::new(modulation_config);
        
        let mut encoder = ProtocolEncoder::new();
        let mut decoder = ProtocolDecoder::new();
        
        let frame_data = encoder.encode_text(test_message)?;
        let samples = modulator.encode_bytes(&frame_data);
        
        let decoded_bytes = demodulator.decode_bytes(&samples)?;
        let messages = decoder.feed_data(&decoded_bytes);
        
        if !messages.is_empty() {
            let decoded_text = messages[0].get_text()?;
            if decoded_text == test_message {
                println!("✓ Frequency config {}: {:.0}Hz/{:.0}Hz - SUCCESS", 
                         i + 1, freq_0, freq_1);
            } else {
                println!("âš  Frequency config {}: {:.0}Hz/{:.0}Hz - DECODE ERROR", 
                         i + 1, freq_0, freq_1);
            }
        } else {
            println!("âš  Frequency config {}: {:.0}Hz/{:.0}Hz - NO MESSAGES", 
                     i + 1, freq_0, freq_1);
        }
    }
    
    Ok(())
}

#[tokio::test]
async fn test_protocol_corruption_recovery() -> UshResult<()> {
    let mut encoder = ProtocolEncoder::new();
    let mut decoder = ProtocolDecoder::new();
    
    let test_message = "Corruption test message";
    let mut frame_data = encoder.encode_text(test_message)?;
    
    // Corrupt some bytes in the middle
    if frame_data.len() > 10 {
        let mid_idx = frame_data.len() / 2;
        frame_data[mid_idx] = 0xFF;
        frame_data[mid_idx + 1] = 0x00;
    }
    
    let messages = decoder.feed_data(&frame_data);
    
    if messages.is_empty() {
        println!("✓ Correctly rejected corrupted message");
    } else {
        // Check if checksum validation caught the corruption
        for message in messages {
            if let Ok(is_valid) = message.verify_checksum() {
                if !is_valid {
                    println!("✓ Checksum validation caught corruption");
                } else {
                    println!("âš  Corrupted message passed checksum validation");
                }
            }
        }
    }
    
    Ok(())
}

#[tokio::test]
async fn test_performance_benchmarks() -> UshResult<()> {
    use std::time::Instant;
    
    let modulation_config = ModulationConfig::default();
    let modulator = FskModulator::new(modulation_config.clone());
    let demodulator = FskDemodulator::new(modulation_config);
    
    let mut encoder = ProtocolEncoder::new();
    let test_message = "Performance test message for benchmarking encoding and decoding speed.";
    
    // Benchmark encoding
    let start = Instant::now();
    let frame_data = encoder.encode_text(test_message)?;
    let protocol_encode_time = start.elapsed();
    
    let start = Instant::now();
    let samples = modulator.encode_bytes(&frame_data);
    let modulation_encode_time = start.elapsed();
    
    // Benchmark decoding
    let start = Instant::now();
    let decoded_bytes = demodulator.decode_bytes(&samples)?;
    let modulation_decode_time = start.elapsed();
    
    let mut decoder = ProtocolDecoder::new();
    let start = Instant::now();
    let messages = decoder.feed_data(&decoded_bytes);
    let protocol_decode_time = start.elapsed();
    
    // Verify correctness
    assert!(!messages.is_empty());
    let decoded_text = messages[0].get_text()?;
    assert_eq!(test_message, decoded_text);
    
    println!("Performance benchmarks:");
    println!("  Protocol encode: {:?}", protocol_encode_time);
    println!("  Modulation encode: {:?}", modulation_encode_time);
    println!("  Modulation decode: {:?}", modulation_decode_time);
    println!("  Protocol decode: {:?}", protocol_decode_time);
    println!("  Total roundtrip: {:?}", 
             protocol_encode_time + modulation_encode_time + 
             modulation_decode_time + protocol_decode_time);
    println!("  Audio duration: {:.2}s", samples.len() as f32 / 44100.0);
    println!("  Data rate: {:.1} chars/s", 
             test_message.len() as f32 / (samples.len() as f32 / 44100.0));
    
    Ok(())
}

#[tokio::test]
async fn test_unicode_support() -> UshResult<()> {
    let modulation_config = ModulationConfig::default();
    let modulator = FskModulator::new(modulation_config.clone());
    let demodulator = FskDemodulator::new(modulation_config);
    
    let mut encoder = ProtocolEncoder::new();
    let mut decoder = ProtocolDecoder::new();
    
    let unicode_messages = vec![
        "Hello 世界", // Chinese
        "Привет мир", // Russian
        "مرحبا بالعالم", // Arabic
        "🌊🔊📡💻🚀", // Emojis
        "Café naïve résumé", // Accented characters
    ];
    
    for (i, message) in unicode_messages.iter().enumerate() {
        let frame_data = encoder.encode_text(message)?;
        let samples = modulator.encode_bytes(&frame_data);
        
        let decoded_bytes = demodulator.decode_bytes(&samples)?;
        let messages = decoder.feed_data(&decoded_bytes);
        
        assert!(!messages.is_empty(), "No messages decoded for Unicode test {}", i);
        let decoded_text = messages[0].get_text()?;
        assert_eq!(*message, decoded_text, "Unicode test {} failed", i);
        
        println!("✓ Unicode test {}: \"{}\"", i + 1, decoded_text);
    }
    
    Ok(())
}