embedded-audio-core 0.2.1

no_std duty-modulated PWM audio: effect banks, tiered DSP, and mixing for Cortex-M
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

#[cfg(feature = "fm")]
use crate::profile::markham::{self, clamp_frequency};

/// One control tick for frequency-modulated buzzer hardware (Markham-style).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct FmTick {
    pub frequency_hz: u32,
    pub active: bool,
}

/// Maps mixed PCM to buzzer frequency (VCO / “PC speaker on piezo”).
#[derive(Debug, Clone, Copy)]
pub struct FmMapper {
    pub center_hz: u32,
    pub span_hz: u32,
    pub silence_threshold: i8,
}

impl FmMapper {
    pub const fn new(center_hz: u32, span_hz: u32, silence_threshold: i8) -> Self {
        Self {
            center_hz,
            span_hz,
            silence_threshold,
        }
    }

    pub const fn map_pcm(&self, pcm: i8) -> FmTick {
        let level = pcm.abs();
        if level <= self.silence_threshold {
            return FmTick {
                frequency_hz: self.center_hz,
                active: false,
            };
        }
        let hz = self.center_hz + (level as u32 * self.span_hz) / 127;
        FmTick {
            frequency_hz: clamp_frequency(hz),
            active: true,
        }
    }

    /// Use when the voice is a pure tone oscillator (Tier A `Tone`).
    pub const fn from_carrier(hz: u32, active: bool) -> FmTick {
        FmTick {
            frequency_hz: if active { clamp_frequency(hz) } else { hz },
            active,
        }
    }
}

#[cfg(feature = "fm")]
impl FmMapper {
    /// Markham firmware defaults (requires `fm` feature).
    pub const fn markham() -> Self {
        Self::new(
            markham::VCO_CENTER_HZ,
            markham::VCO_SPAN_HZ,
            markham::SILENCE_THRESHOLD,
        )
    }
}