futuresdr 0.0.39

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
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use seify::Args;
use seify::Device;
use seify::DeviceTrait;
use seify::Direction;
use seify::GenericDevice;

use crate::blocks::seify::Config;
use crate::blocks::seify::Sink;
use crate::blocks::seify::Source;
use crate::num_complex::Complex32;
use crate::runtime::Error;
use crate::runtime::buffer::CpuBufferReader;
use crate::runtime::buffer::CpuBufferWriter;

pub trait IntoAntenna {
    fn into(self) -> Option<String>;
}

impl IntoAntenna for &str {
    fn into(self) -> Option<String> {
        Some(self.to_string())
    }
}

impl IntoAntenna for String {
    fn into(self) -> Option<String> {
        Some(self)
    }
}

impl IntoAntenna for Option<String> {
    fn into(self) -> Option<String> {
        self
    }
}

/// Seify Device builder
pub struct Builder<D: DeviceTrait + Clone> {
    channels: Vec<usize>,
    config: Config,
    dev: Device<D>,
    start_time: Option<i64>,
}

impl Builder<GenericDevice> {
    /// Create Seify Device builder
    pub fn new<A: TryInto<Args>>(args: A) -> Result<Self, Error> {
        let args = args.try_into().or(Err(Error::SeifyArgsConversionError))?;
        let dev = Device::from_args(args)?;
        Ok(Self {
            channels: vec![0],
            config: Config::new(),
            dev,
            start_time: None,
        })
    }
}

impl<D: DeviceTrait + Clone> Builder<D> {
    /// Create Seify Device builder
    pub fn from_device(dev: Device<D>) -> Self {
        Self {
            channels: vec![0],
            config: Config::new(),
            dev,
            start_time: None,
        }
    }
    /// Seify device
    pub fn device<D2: DeviceTrait + Clone>(self, dev: Device<D2>) -> Builder<D2> {
        Builder {
            channels: self.channels,
            config: self.config,
            dev,
            start_time: self.start_time,
        }
    }
    /// Channel
    pub fn channel(mut self, c: usize) -> Self {
        self.channels = vec![c];
        self
    }
    /// Channels
    pub fn channels(mut self, c: Vec<usize>) -> Self {
        self.channels = c;
        self
    }
    /// Antenna
    pub fn antenna<A: IntoAntenna>(mut self, s: A) -> Self {
        self.config.antenna = s.into();
        self
    }
    /// Bandwidth
    pub fn bandwidth(mut self, b: f64) -> Self {
        self.config.bandwidth = Some(b);
        self
    }
    /// Frequency
    pub fn frequency(mut self, f: f64) -> Self {
        self.config.freq = Some(f);
        self
    }
    /// Gain
    pub fn gain(mut self, g: f64) -> Self {
        self.config.gain = Some(g);
        self
    }
    /// Sample Rate
    pub fn sample_rate(mut self, s: f64) -> Self {
        self.config.sample_rate = Some(s);
        self
    }
    /// Start Time
    pub fn start_time(mut self, s: i64) -> Self {
        self.start_time = Some(s);
        self
    }
    /// Build Typed Seify Source
    pub fn build_source(self) -> Result<Source<D>, Error> {
        self.config
            .apply(&self.dev, &self.channels, Direction::Rx)?;
        Ok(Source::new(self.dev, self.channels, self.start_time))
    }
    /// Build Typed Seify Source
    pub fn build_source_with_buffer<B: CpuBufferWriter<Item = Complex32>>(
        self,
    ) -> Result<Source<D, B>, Error> {
        self.config
            .apply(&self.dev, &self.channels, Direction::Rx)?;
        Ok(Source::<D, B>::new(
            self.dev,
            self.channels,
            self.start_time,
        ))
    }
    /// Builder Typed Seify Sink
    pub fn build_sink(self) -> Result<Sink<D>, Error> {
        self.config
            .apply(&self.dev, &self.channels, Direction::Tx)?;
        Ok(Sink::new(self.dev, self.channels, self.start_time))
    }
    /// Builder Typed Seify Sink
    pub fn build_sink_with_buffer<B: CpuBufferReader<Item = Complex32>>(
        self,
    ) -> Result<Sink<D, B>, Error> {
        self.config
            .apply(&self.dev, &self.channels, Direction::Tx)?;
        Ok(Sink::<D, B>::new(self.dev, self.channels, self.start_time))
    }
}