embassy-max4466 0.1.2

Driver async no_std pour le capteur MAX4466, basé sur Embassy.
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

# embassy-max4466

[![Documentation](https://docs.rs/embassy-max4466/badge.svg)](https://docs.rs/embassy-max4466)
[![Crate](https://img.shields.io/crates/v/embassy-max4466.svg)](https://crates.io/crates/embassy-max4466)
[![License: GPL-2.0](https://img.shields.io/badge/license-GPL--2.0--or--later-blue.svg)](LICENSE)

Driver async `no_std` pour le capteur microphone **MAX4466**, basé sur [Embassy](https://embassy.dev).

# La version 0.1.1 fournit un exemple clé en main 

## Features

| Feature          | Description                                        |
|------------------|----------------------------------------------------|
| *(défaut)*       | Valeur ADC brute, aucun filtre                     |
| `filter-ema`     | Filtre EMA (lissage exponentiel, alpha configurable) |
| `filter-median`  | Filtre médian (fenêtre glissante de 5 samples)     |

Les deux features sont cumulables.


## Utilisation

### Cargo.toml

```toml
# Valeur brute uniquement
embassy-max4466 = { version = "0.1.2" }

# Avec filtre EMA
embassy-max4466 = { version = "0.1.2", features = ["filter-ema"] }

# Avec filtre médian
embassy-max4466 = { version = "0.1.2", features = ["filter-median"] }

# Les deux
embassy-max4466 = { version = "0.1.2", features = ["filter-ema", "filter-median"] }
```

### Implémentation du trait `AdcReader` (exemple embassy-rp)

```rust
use embassy_max4466::driver::AdcReader;
use embassy_rp::adc::{Adc, Async, Channel};

pub struct RpAdc<'d> {
    adc: Adc<'d, Async>,
    channel: Channel<'d>,
}

impl AdcReader for RpAdc<'_> {
    async fn read(&mut self) -> u16 {
        self.adc.read(&mut self.channel).await.unwrap_or(0)
    }
}
```

### Exemple complet

```rust
use embassy_executor::Spawner;
use embassy_max4466::{Max4466, signals::MIC_SIGNAL};

#[embassy_executor::task]
async fn micro_task(adc: RpAdc<'static>) {
    let mut mic = Max4466::new(adc);
    mic.calibrate().await;

    loop {
        let amplitude = mic.read_amplitude(50).await;
        defmt::info!("Amplitude: {}", amplitude);
    }
}

#[embassy_executor::task]
async fn afficher_signal() {
    loop {
        let data = MIC_SIGNAL.wait().await;
        defmt::info!("raw={} amplitude={}", data.raw, data.amplitude);
    }
}
```


## Exemple simple

```rust
use embassy_executor::Spawner;
use embassy_max4466::{Max4466, signals::MIC_SIGNAL};
use embassy_max4466::driver::AdcReader;

#[embassy_executor::task]
async fn audio_task(mut adc: impl AdcReader) {
    let mut mic = Max4466::new(adc);
    mic.calibrate().await;

    loop {
        let amplitude = mic.read_amplitude(50).await;
        defmt::info!("Amplitude: {}", amplitude);
        Timer::after_millis(100).await;
    }
}

#[embassy_executor::task]
async fn signal_handler() {
    loop {
        let data = MIC_SIGNAL.wait().await;
        defmt::info!("Raw: {}, Amplitude: {}", data.raw, data.amplitude);
    }
}
```

## Licence

GPL-2.0-or-later