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
|
/* -*- c++ -*- */
/*
* Copyright 2010-2013 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 <uhd/usrp_source.h>
#include <uhd/convert.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 gr_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);
#ifdef GR_UHD_USE_STREAM_API
const size_t size = ::uhd::convert::get_bytes_per_item(args.cpu_format);
#else
size_t size = 0;
if(args.cpu_format == "fc32")
size = 8;
if(args.cpu_format == "sc16")
size = 4;
#endif
return gr_make_io_signature(nchan, nchan, size);
}
/***********************************************************************
* UHD Multi USRP Source Impl
**********************************************************************/
class usrp_source_impl : public usrp_source
{
public:
usrp_source_impl(const ::uhd::device_addr_t &device_addr,
const ::uhd::stream_args_t &stream_args);
~usrp_source_impl();
void setup_rpc();
// 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);
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::sensor_value_t get_mboard_sensor(const std::string &name, size_t mboard);
std::vector<std::string> get_mboard_sensor_names(size_t mboard);
std::string get_time_source(const size_t mboard);
std::vector<std::string> get_time_sources(const size_t mboard);
std::string get_clock_source(const size_t mboard);
std::vector<std::string> get_clock_sources(const size_t mboard);
double get_clock_rate(size_t mboard);
::uhd::time_spec_t get_time_now(size_t mboard = 0);
::uhd::time_spec_t get_time_last_pps(size_t mboard);
::uhd::usrp::dboard_iface::sptr get_dboard_iface(size_t chan);
::uhd::usrp::multi_usrp::sptr get_device(void);
// 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_antenna(const std::string &ant, size_t chan);
void set_bandwidth(double bandwidth, 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_iq_balance(const std::complex<double> &correction, size_t chan);
void set_clock_config(const ::uhd::clock_config_t &clock_config, size_t mboard);
void set_time_source(const std::string &source, const size_t mboard);
void set_clock_source(const std::string &source, const size_t mboard);
void set_clock_rate(double rate, size_t mboard);
void set_time_now(const ::uhd::time_spec_t &time_spec, size_t mboard);
void set_time_next_pps(const ::uhd::time_spec_t &time_spec);
void set_time_unknown_pps(const ::uhd::time_spec_t &time_spec);
void set_command_time(const ::uhd::time_spec_t &time_spec, size_t mboard);
void set_user_register(const uint8_t addr, const uint32_t data, size_t mboard);
void set_start_time(const ::uhd::time_spec_t &time);
void issue_stream_cmd(const ::uhd::stream_cmd_t &cmd);
void clear_command_time(size_t mboard);
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);
private:
::uhd::usrp::multi_usrp::sptr _dev;
const ::uhd::stream_args_t _stream_args;
boost::shared_ptr< ::uhd::io_type_t > _type;
#ifdef GR_UHD_USE_STREAM_API
::uhd::rx_streamer::sptr _rx_stream;
size_t _samps_per_packet;
#endif
size_t _nchan;
bool _stream_now, _tag_now;
::uhd::rx_metadata_t _metadata;
pmt::pmt_t _id;
::uhd::time_spec_t _start_time;
bool _start_time_set;
//tag shadows
double _samp_rate;
double _center_freq;
};
} /* namespace uhd */
} /* namespace gr */
|
