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
|
/* -*- c++ -*- */
/*
* Copyright 2010-2016 Free Software Foundation, Inc.
*
* This file is part of GNU Radio
*
* GNU Radio is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3, or (at your option)
* any later version.
*
* GNU Radio is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Radio; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street,
* Boston, MA 02110-1301, USA.
*/
#include "usrp_block_impl.h"
#include <gnuradio/uhd/usrp_source.h>
#include <uhd/convert.hpp>
#include <boost/thread/mutex.hpp>
static const pmt::pmt_t TIME_KEY = pmt::string_to_symbol("rx_time");
static const pmt::pmt_t RATE_KEY = pmt::string_to_symbol("rx_rate");
static const pmt::pmt_t FREQ_KEY = pmt::string_to_symbol("rx_freq");
namespace gr {
namespace uhd {
inline io_signature::sptr
args_to_io_sig(const ::uhd::stream_args_t &args)
{
const size_t nchan = std::max<size_t>(args.channels.size(), 1);
const size_t size = ::uhd::convert::get_bytes_per_item(args.cpu_format);
return io_signature::make(nchan, nchan, size);
}
/***********************************************************************
* UHD Multi USRP Source Impl
**********************************************************************/
class usrp_source_impl : public usrp_source, public usrp_block_impl
{
public:
usrp_source_impl(const ::uhd::device_addr_t &device_addr,
const ::uhd::stream_args_t &stream_args,
const bool issue_stream_cmd_on_start = true);
~usrp_source_impl();
// Get Commands
::uhd::dict<std::string, std::string> get_usrp_info(size_t chan);
std::string get_subdev_spec(size_t mboard);
double get_samp_rate(void);
::uhd::meta_range_t get_samp_rates(void);
double get_center_freq(size_t chan);
::uhd::freq_range_t get_freq_range(size_t chan);
double get_gain(size_t chan);
double get_gain(const std::string &name, size_t chan);
double get_normalized_gain(size_t chan);
std::vector<std::string> get_gain_names(size_t chan);
::uhd::gain_range_t get_gain_range(size_t chan);
::uhd::gain_range_t get_gain_range(const std::string &name, size_t chan);
std::string get_antenna(size_t chan);
std::vector<std::string> get_antennas(size_t chan);
::uhd::sensor_value_t get_sensor(const std::string &name, size_t chan);
std::vector<std::string> get_sensor_names(size_t chan);
::uhd::usrp::dboard_iface::sptr get_dboard_iface(size_t chan);
std::vector<std::string> get_lo_names(size_t chan);
const std::string get_lo_source(const std::string &name, size_t chan);
std::vector<std::string> get_lo_sources(const std::string &name, size_t chan);
bool get_lo_export_enabled(const std::string &name, size_t chan);
double get_lo_freq(const std::string &name, size_t chan);
::uhd::freq_range_t get_lo_freq_range(const std::string &name, size_t chan);
// Set Commands
void set_subdev_spec(const std::string &spec, size_t mboard);
void set_samp_rate(double rate);
::uhd::tune_result_t set_center_freq(const ::uhd::tune_request_t tune_request,
size_t chan);
void set_gain(double gain, size_t chan);
void set_gain(double gain, const std::string &name, size_t chan);
void set_rx_agc(const bool enable, size_t chan);
void set_normalized_gain(double gain, size_t chan);
void set_antenna(const std::string &ant, size_t chan);
void set_bandwidth(double bandwidth, size_t chan);
double get_bandwidth(size_t chan);
::uhd::freq_range_t get_bandwidth_range(size_t chan);
void set_auto_dc_offset(const bool enable, size_t chan);
void set_dc_offset(const std::complex<double> &offset, size_t chan);
void set_auto_iq_balance(const bool enable, size_t chan);
void set_iq_balance(const std::complex<double> &correction, size_t chan);
void set_stream_args(const ::uhd::stream_args_t &stream_args);
void set_start_time(const ::uhd::time_spec_t &time);
void set_lo_source(const std::string &src, const std::string &name = ALL_LOS, size_t chan = 0);
void set_lo_export_enabled(bool enabled, const std::string &name = ALL_LOS, size_t chan = 0);
double set_lo_freq(double freq, const std::string &name, size_t chan);
void issue_stream_cmd(const ::uhd::stream_cmd_t &cmd);
void set_recv_timeout(const double timeout, const bool one_packet);
void flush(void);
bool start(void);
bool stop(void);
std::vector<std::complex<float> > finite_acquisition(const size_t nsamps);
std::vector<std::vector<std::complex<float> > > finite_acquisition_v(const size_t nsamps);
int work(int noutput_items,
gr_vector_const_void_star &input_items,
gr_vector_void_star &output_items);
void setup_rpc();
private:
//! Like set_center_freq(), but uses _curr_freq and _curr_lo_offset
::uhd::tune_result_t _set_center_freq_from_internals(size_t chan, pmt::pmt_t direction);
void _cmd_handler_tag(const pmt::pmt_t &tag);
::uhd::rx_streamer::sptr _rx_stream;
size_t _samps_per_packet;
//! Timeout value for UHD's recv() call. Lower values mean lower latency.
double _recv_timeout;
//! one_packet value for UHD's recv() call. 'true' is lower latency.
bool _recv_one_packet;
bool _tag_now;
::uhd::rx_metadata_t _metadata;
pmt::pmt_t _id;
bool _issue_stream_cmd_on_start;
//tag shadows
double _samp_rate;
boost::recursive_mutex d_mutex;
};
} /* namespace uhd */
} /* namespace gr */
|
