futuresdr 0.8.0

An Experimental Async SDR Runtime for Heterogeneous Architectures.
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

use seify::ChannelControls;
use seify::Range;
use std::collections::HashMap;

use crate::runtime::Error;
use crate::runtime::Pmt;

/// Controllable settings exposed by one configured Seify source channel.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SourceCapabilities {
    /// Configured-channel index.
    pub chan: usize,
    /// Selectable antenna names.
    pub antenna: Option<Vec<String>>,
    /// Supported hardware bandwidths in Hz.
    pub bandwidth: Option<Range>,
    /// Supported center frequencies in Hz.
    pub freq: Option<Range>,
    /// Supported overall gains in dB.
    pub gain: Option<Range>,
    /// Supported sample rates in samples per second.
    pub sample_rate: Option<Range>,
}

impl SourceCapabilities {
    pub(crate) fn from_channel_controls(chan: usize, controls: &ChannelControls) -> Self {
        Self {
            chan,
            antenna: controls.antennas.clone(),
            bandwidth: controls.bandwidth_range.clone(),
            freq: controls.frequency_range.clone(),
            gain: controls.gain_range.clone(),
            sample_rate: controls.sample_rate_range.clone(),
        }
    }

    /// Generate a serializable [`Pmt`].
    pub fn to_serializable_pmt(&self) -> Pmt {
        let mut map = HashMap::from([("chan".to_string(), Pmt::U64(self.chan as u64))]);
        if let Some(antenna) = &self.antenna {
            map.insert(
                "antenna".to_string(),
                Pmt::VecPmt(antenna.iter().cloned().map(Pmt::String).collect()),
            );
        }
        if let Some(bandwidth) = &self.bandwidth {
            map.insert("bandwidth".to_string(), bandwidth.into());
        }
        if let Some(freq) = &self.freq {
            map.insert("freq".to_string(), freq.into());
        }
        if let Some(gain) = &self.gain {
            map.insert("gain".to_string(), gain.into());
        }
        if let Some(sample_rate) = &self.sample_rate {
            map.insert("sample_rate".to_string(), sample_rate.into());
        }
        Pmt::MapStrPmt(map)
    }
}

pub(super) fn configured_channel_id(value: &Pmt) -> Option<usize> {
    match value {
        Pmt::Null | Pmt::Ok => Some(0),
        Pmt::U32(chan) => Some(*chan as usize),
        Pmt::U64(chan) => Some(*chan as usize),
        Pmt::Usize(chan) => Some(*chan),
        _ => None,
    }
}

impl TryFrom<Pmt> for SourceCapabilities {
    type Error = Error;

    fn try_from(value: Pmt) -> Result<Self, Self::Error> {
        let Pmt::MapStrPmt(mut map) = value else {
            return Err(Error::PmtConversionError);
        };

        let chan = match map.remove("chan") {
            Some(Pmt::U32(chan)) => chan as usize,
            Some(Pmt::U64(chan)) => chan as usize,
            Some(Pmt::Usize(chan)) => chan,
            _ => return Err(Error::PmtConversionError),
        };
        let antenna = match map.remove("antenna") {
            Some(Pmt::VecPmt(values)) => Some(
                values
                    .into_iter()
                    .map(|value| match value {
                        Pmt::String(value) => Ok(value),
                        _ => Err(Error::PmtConversionError),
                    })
                    .collect::<Result<Vec<_>, _>>()?,
            ),
            None => None,
            _ => return Err(Error::PmtConversionError),
        };

        Ok(Self {
            chan,
            antenna,
            bandwidth: optional_range(map.remove("bandwidth"))?,
            freq: optional_range(map.remove("freq"))?,
            gain: optional_range(map.remove("gain"))?,
            sample_rate: optional_range(map.remove("sample_rate"))?,
        })
    }
}

fn optional_range(value: Option<Pmt>) -> Result<Option<Range>, Error> {
    value
        .map(|value| Range::try_from(value).map_err(|_| Error::PmtConversionError))
        .transpose()
}

#[cfg(test)]
mod tests {
    use super::*;
    use seify::RangeItem;

    #[test]
    fn serializable_pmt_round_trip() {
        let capabilities = SourceCapabilities {
            chan: 1,
            antenna: Some(vec!["RX".to_string(), "RX2".to_string()]),
            freq: Some(Range::new(vec![RangeItem::Interval(1e6, 6e9)])),
            gain: Some(Range::new(vec![RangeItem::Step(0.0, 40.0, 8.0)])),
            sample_rate: Some(Range::new(vec![RangeItem::Value(10e6)])),
            ..Default::default()
        };

        let decoded = SourceCapabilities::try_from(capabilities.to_serializable_pmt()).unwrap();
        assert_eq!(decoded, capabilities);
    }
}