aboutsummaryrefslogtreecommitdiffstats
path: root/host/lib/usrp/usrp2
diff options
context:
space:
mode:
Diffstat (limited to 'host/lib/usrp/usrp2')
-rw-r--r--host/lib/usrp/usrp2/dboard_impl.cpp13
-rw-r--r--host/lib/usrp/usrp2/dsp_impl.cpp71
-rw-r--r--host/lib/usrp/usrp2/fw_common.h14
-rw-r--r--host/lib/usrp/usrp2/io_impl.cpp329
-rw-r--r--host/lib/usrp/usrp2/mboard_impl.cpp125
-rw-r--r--host/lib/usrp/usrp2/usrp2_impl.cpp82
-rw-r--r--host/lib/usrp/usrp2/usrp2_impl.hpp37
7 files changed, 412 insertions, 259 deletions
diff --git a/host/lib/usrp/usrp2/dboard_impl.cpp b/host/lib/usrp/usrp2/dboard_impl.cpp
index 32c64f541..6d957436e 100644
--- a/host/lib/usrp/usrp2/dboard_impl.cpp
+++ b/host/lib/usrp/usrp2/dboard_impl.cpp
@@ -16,6 +16,7 @@
//
#include <uhd/utils.hpp>
+#include <boost/format.hpp>
#include "usrp2_impl.hpp"
#include "dboard_interface.hpp"
@@ -70,7 +71,7 @@ void usrp2_impl::rx_dboard_get(const wax::obj &key_, wax::obj &val){
boost::tie(key, name) = extract_named_prop(key_);
//handle the get request conditioned on the key
- switch(wax::cast<dboard_prop_t>(key)){
+ switch(key.as<dboard_prop_t>()){
case DBOARD_PROP_NAME:
val = std::string("usrp2 dboard (rx unit)");
return;
@@ -83,8 +84,8 @@ void usrp2_impl::rx_dboard_get(const wax::obj &key_, wax::obj &val){
val = _dboard_manager->get_rx_subdev_names();
return;
- case DBOARD_PROP_CODEC:
- throw std::runtime_error("unhandled prop in usrp2 dboard");
+ //case DBOARD_PROP_CODEC:
+ // throw std::runtime_error("unhandled prop in usrp2 dboard");
}
}
@@ -100,7 +101,7 @@ void usrp2_impl::tx_dboard_get(const wax::obj &key_, wax::obj &val){
boost::tie(key, name) = extract_named_prop(key_);
//handle the get request conditioned on the key
- switch(wax::cast<dboard_prop_t>(key)){
+ switch(key.as<dboard_prop_t>()){
case DBOARD_PROP_NAME:
val = std::string("usrp2 dboard (tx unit)");
return;
@@ -113,8 +114,8 @@ void usrp2_impl::tx_dboard_get(const wax::obj &key_, wax::obj &val){
val = _dboard_manager->get_tx_subdev_names();
return;
- case DBOARD_PROP_CODEC:
- throw std::runtime_error("unhandled prop in usrp2 dboard");
+ //case DBOARD_PROP_CODEC:
+ // throw std::runtime_error("unhandled prop in usrp2 dboard");
}
}
diff --git a/host/lib/usrp/usrp2/dsp_impl.cpp b/host/lib/usrp/usrp2/dsp_impl.cpp
index 22c00d99a..7520c1757 100644
--- a/host/lib/usrp/usrp2/dsp_impl.cpp
+++ b/host/lib/usrp/usrp2/dsp_impl.cpp
@@ -16,11 +16,15 @@
//
#include <uhd/utils.hpp>
+#include <boost/format.hpp>
#include <boost/assign/list_of.hpp>
#include "usrp2_impl.hpp"
using namespace uhd;
+static const size_t default_decim = 16;
+static const size_t default_interp = 16;
+
/***********************************************************************
* DDC Helper Methods
**********************************************************************/
@@ -36,6 +40,10 @@ static uint32_t calculate_freq_word_and_update_actual_freq(freq_t &freq, freq_t
return freq_word;
}
+static uint32_t calculate_iq_scale_word(int16_t i, int16_t q){
+ return (uint16_t(i) << 16) | (uint16_t(q) << 0);
+}
+
void usrp2_impl::init_ddc_config(void){
//create the ddc in the rx dsp dict
_rx_dsps["ddc0"] = wax_obj_proxy(
@@ -44,7 +52,7 @@ void usrp2_impl::init_ddc_config(void){
);
//initial config and update
- _ddc_decim = 16;
+ _ddc_decim = default_decim;
_ddc_freq = 0;
update_ddc_config();
@@ -61,6 +69,10 @@ void usrp2_impl::update_ddc_config(void){
calculate_freq_word_and_update_actual_freq(_ddc_freq, get_master_clock_freq())
);
out_data.data.ddc_args.decim = htonl(_ddc_decim);
+ static const uint32_t default_rx_scale_iq = 1024;
+ out_data.data.ddc_args.scale_iq = htonl(
+ calculate_iq_scale_word(default_rx_scale_iq, default_rx_scale_iq)
+ );
//send and recv
usrp2_ctrl_data_t in_data = ctrl_send_and_recv(out_data);
@@ -74,6 +86,7 @@ void usrp2_impl::update_ddc_enabled(void){
out_data.data.streaming.enabled = (_ddc_enabled)? 1 : 0;
out_data.data.streaming.secs = htonl(_ddc_stream_at.secs);
out_data.data.streaming.ticks = htonl(_ddc_stream_at.ticks);
+ out_data.data.streaming.samples = htonl(_max_rx_samples_per_packet);
//send and recv
usrp2_ctrl_data_t in_data = ctrl_send_and_recv(out_data);
@@ -89,7 +102,7 @@ void usrp2_impl::update_ddc_enabled(void){
void usrp2_impl::ddc_get(const wax::obj &key, wax::obj &val){
//handle the case where the key is an expected dsp property
if (key.type() == typeid(dsp_prop_t)){
- switch(wax::cast<dsp_prop_t>(key)){
+ switch(key.as<dsp_prop_t>()){
case DSP_PROP_NAME:
val = std::string("usrp2 ddc0");
return;
@@ -98,7 +111,7 @@ void usrp2_impl::ddc_get(const wax::obj &key, wax::obj &val){
prop_names_t others = boost::assign::list_of
("rate")
("decim")
- ("decim_rates")
+ ("decims")
("freq")
("enabled")
("stream_at")
@@ -110,7 +123,7 @@ void usrp2_impl::ddc_get(const wax::obj &key, wax::obj &val){
}
//handle string-based properties specific to this dsp
- std::string key_name = wax::cast<std::string>(key);
+ std::string key_name = key.as<std::string>();
if (key_name == "rate"){
val = get_master_clock_freq();
return;
@@ -119,7 +132,7 @@ void usrp2_impl::ddc_get(const wax::obj &key, wax::obj &val){
val = _ddc_decim;
return;
}
- else if (key_name == "decim_rates"){
+ else if (key_name == "decims"){
val = _allowed_decim_and_interp_rates;
return;
}
@@ -139,20 +152,19 @@ void usrp2_impl::ddc_get(const wax::obj &key, wax::obj &val){
void usrp2_impl::ddc_set(const wax::obj &key, const wax::obj &val){
//handle string-based properties specific to this dsp
- std::string key_name = wax::cast<std::string>(key);
+ std::string key_name = key.as<std::string>();
if (key_name == "decim"){
- size_t new_decim = wax::cast<size_t>(val);
- ASSERT_THROW(std::has(
- _allowed_decim_and_interp_rates.begin(),
- _allowed_decim_and_interp_rates.end(),
- new_decim
- ));
+ size_t new_decim = val.as<size_t>();
+ assert_has(
+ _allowed_decim_and_interp_rates,
+ new_decim, "usrp2 decimation"
+ );
_ddc_decim = new_decim; //shadow
update_ddc_config();
return;
}
else if (key_name == "freq"){
- freq_t new_freq = wax::cast<freq_t>(val);
+ freq_t new_freq = val.as<freq_t>();
ASSERT_THROW(new_freq <= get_master_clock_freq()/2.0);
ASSERT_THROW(new_freq >= -get_master_clock_freq()/2.0);
_ddc_freq = new_freq; //shadow
@@ -160,13 +172,13 @@ void usrp2_impl::ddc_set(const wax::obj &key, const wax::obj &val){
return;
}
else if (key_name == "enabled"){
- bool new_enabled = wax::cast<bool>(val);
+ bool new_enabled = val.as<bool>();
_ddc_enabled = new_enabled; //shadow
update_ddc_enabled();
return;
}
else if (key_name == "stream_at"){
- time_spec_t new_stream_at = wax::cast<time_spec_t>(val);
+ time_spec_t new_stream_at = val.as<time_spec_t>();
_ddc_stream_at = new_stream_at; //shadow
//update_ddc_enabled(); //dont update from here
return;
@@ -188,7 +200,7 @@ void usrp2_impl::init_duc_config(void){
);
//initial config and update
- _duc_interp = 16;
+ _duc_interp = default_interp;
_duc_freq = 0;
update_duc_config();
}
@@ -209,7 +221,9 @@ void usrp2_impl::update_duc_config(void){
calculate_freq_word_and_update_actual_freq(_duc_freq, get_master_clock_freq())
);
out_data.data.duc_args.interp = htonl(_duc_interp);
- out_data.data.duc_args.scale_iq = htonl(scale);
+ out_data.data.duc_args.scale_iq = htonl(
+ calculate_iq_scale_word(scale, scale)
+ );
//send and recv
usrp2_ctrl_data_t in_data = ctrl_send_and_recv(out_data);
@@ -222,7 +236,7 @@ void usrp2_impl::update_duc_config(void){
void usrp2_impl::duc_get(const wax::obj &key, wax::obj &val){
//handle the case where the key is an expected dsp property
if (key.type() == typeid(dsp_prop_t)){
- switch(wax::cast<dsp_prop_t>(key)){
+ switch(key.as<dsp_prop_t>()){
case DSP_PROP_NAME:
val = std::string("usrp2 duc0");
return;
@@ -231,7 +245,7 @@ void usrp2_impl::duc_get(const wax::obj &key, wax::obj &val){
prop_names_t others = boost::assign::list_of
("rate")
("interp")
- ("interp_rates")
+ ("interps")
("freq")
;
val = others;
@@ -241,7 +255,7 @@ void usrp2_impl::duc_get(const wax::obj &key, wax::obj &val){
}
//handle string-based properties specific to this dsp
- std::string key_name = wax::cast<std::string>(key);
+ std::string key_name = key.as<std::string>();
if (key_name == "rate"){
val = get_master_clock_freq();
return;
@@ -250,7 +264,7 @@ void usrp2_impl::duc_get(const wax::obj &key, wax::obj &val){
val = _duc_interp;
return;
}
- else if (key_name == "interp_rates"){
+ else if (key_name == "interps"){
val = _allowed_decim_and_interp_rates;
return;
}
@@ -266,20 +280,19 @@ void usrp2_impl::duc_get(const wax::obj &key, wax::obj &val){
void usrp2_impl::duc_set(const wax::obj &key, const wax::obj &val){
//handle string-based properties specific to this dsp
- std::string key_name = wax::cast<std::string>(key);
+ std::string key_name = key.as<std::string>();
if (key_name == "interp"){
- size_t new_interp = wax::cast<size_t>(val);
- ASSERT_THROW(std::has(
- _allowed_decim_and_interp_rates.begin(),
- _allowed_decim_and_interp_rates.end(),
- new_interp
- ));
+ size_t new_interp = val.as<size_t>();
+ assert_has(
+ _allowed_decim_and_interp_rates,
+ new_interp, "usrp2 interpolation"
+ );
_duc_interp = new_interp; //shadow
update_duc_config();
return;
}
else if (key_name == "freq"){
- freq_t new_freq = wax::cast<freq_t>(val);
+ freq_t new_freq = val.as<freq_t>();
ASSERT_THROW(new_freq <= get_master_clock_freq()/2.0);
ASSERT_THROW(new_freq >= -get_master_clock_freq()/2.0);
_duc_freq = new_freq; //shadow
diff --git a/host/lib/usrp/usrp2/fw_common.h b/host/lib/usrp/usrp2/fw_common.h
index 3def8ddaa..10c1ef8cf 100644
--- a/host/lib/usrp/usrp2/fw_common.h
+++ b/host/lib/usrp/usrp2/fw_common.h
@@ -27,6 +27,10 @@
extern "C" {
#endif
+// size of the vrt header and trailer to the host
+#define USRP2_HOST_RX_VRT_HEADER_WORDS32 5
+#define USRP2_HOST_RX_VRT_TRAILER_WORDS32 1 //FIXME fpga sets wrong header size when no trailer present
+
// udp ports for the usrp2 communication
// Dynamic and/or private ports: 49152-65535
#define USRP2_UDP_CTRL_PORT 49152
@@ -87,6 +91,9 @@ typedef enum{
USRP2_CTRL_ID_SETUP_THIS_DUC_FOR_ME_BRO,
USRP2_CTRL_ID_TOTALLY_SETUP_THE_DUC_DUDE,
+ USRP2_CTRL_ID_GOT_A_NEW_TIME_FOR_YOU_BRO,
+ USRP2_CTRL_ID_SWEET_I_GOT_THAT_TIME_DUDE,
+
USRP2_CTRL_ID_PEACE_OUT
} usrp2_ctrl_id_t;
@@ -168,18 +175,25 @@ typedef struct{
struct {
uint32_t freq_word;
uint32_t decim;
+ uint32_t scale_iq;
} ddc_args;
struct {
uint8_t enabled;
uint8_t _pad[3];
uint32_t secs;
uint32_t ticks;
+ uint32_t samples;
} streaming;
struct {
uint32_t freq_word;
uint32_t interp;
uint32_t scale_iq;
} duc_args;
+ struct {
+ uint32_t secs;
+ uint32_t ticks;
+ uint8_t now;
+ } time_args;
} data;
} usrp2_ctrl_data_t;
diff --git a/host/lib/usrp/usrp2/io_impl.cpp b/host/lib/usrp/usrp2/io_impl.cpp
index 43334ddc6..cc7746720 100644
--- a/host/lib/usrp/usrp2/io_impl.cpp
+++ b/host/lib/usrp/usrp2/io_impl.cpp
@@ -16,12 +16,13 @@
//
#include <complex>
-#include <boost/shared_array.hpp>
#include <boost/format.hpp>
#include "usrp2_impl.hpp"
using namespace uhd;
using namespace uhd::usrp;
+using namespace uhd::transport;
+namespace asio = boost::asio;
/***********************************************************************
* Constants
@@ -29,214 +30,228 @@ using namespace uhd::usrp;
typedef std::complex<float> fc32_t;
typedef std::complex<int16_t> sc16_t;
-static const float float_scale_factor = pow(2.0, 15);
-
-//max length with header, stream id, seconds, fractional seconds
-static const size_t max_vrt_header_words = 5;
+static const float shorts_per_float = pow(2.0, 15);
+static const float floats_per_short = 1.0/shorts_per_float;
/***********************************************************************
* Helper Functions
**********************************************************************/
-static inline void host_floats_to_usrp2_shorts(
- int16_t *usrp2_shorts,
- const float *host_floats,
- size_t num_samps
-){
- for(size_t i = 0; i < num_samps; i++){
- usrp2_shorts[i] = htons(int16_t(host_floats[i]*float_scale_factor));
- }
+void usrp2_impl::io_init(void){
+ //initially empty copy buffer
+ _rx_copy_buff = asio::buffer("", 0);
+
+ //send a small data packet so the usrp2 knows the udp source port
+ uint32_t zero_data = 0;
+ _data_transport->send(asio::buffer(&zero_data, sizeof(zero_data)));
+}
+
+#define unrolled_loop(__i, __len, __inst) {\
+ size_t __i = 0; \
+ while(__i < (__len & ~0x7)){ \
+ __inst; __i++; __inst; __i++; \
+ __inst; __i++; __inst; __i++; \
+ __inst; __i++; __inst; __i++; \
+ __inst; __i++; __inst; __i++; \
+ } \
+ while(__i < __len){ \
+ __inst; __i++;\
+ } \
}
-static inline void usrp2_shorts_to_host_floats(
- float *host_floats,
- const int16_t *usrp2_shorts,
+// set a boolean flag that indicates the endianess
+#ifdef HAVE_BIG_ENDIAN
+static const bool is_big_endian = true;
+#else
+static const bool is_big_endian = false;
+#endif
+
+static inline void host_floats_to_usrp2_items(
+ uint32_t *usrp2_items,
+ const fc32_t *host_floats,
size_t num_samps
){
- for(size_t i = 0; i < num_samps; i++){
- host_floats[i] = float(ntohs(usrp2_shorts[i])/float_scale_factor);
- }
+ unrolled_loop(i, num_samps,{
+ uint16_t real = host_floats[i].real()*shorts_per_float;
+ uint16_t imag = host_floats[i].imag()*shorts_per_float;
+ usrp2_items[i] = htonl((real << 16) | (imag << 0));
+ });
}
-static inline void host_shorts_to_usrp2_shorts(
- int16_t *usrp2_shorts,
- const int16_t *host_shorts,
+static inline void usrp2_items_to_host_floats(
+ fc32_t *host_floats,
+ const uint32_t *usrp2_items,
size_t num_samps
){
- for(size_t i = 0; i < num_samps; i++){
- usrp2_shorts[i] = htons(host_shorts[i]);
- }
+ unrolled_loop(i, num_samps,{
+ uint32_t item = ntohl(usrp2_items[i]);
+ int16_t real = item >> 16;
+ int16_t imag = item >> 0;
+ host_floats[i] = fc32_t(real*floats_per_short, imag*floats_per_short);
+ });
}
-static inline void usrp2_shorts_to_host_shorts(
- int16_t *host_shorts,
- const int16_t *usrp2_shorts,
+static inline void host_items_to_usrp2_items(
+ uint32_t *usrp2_items,
+ const uint32_t *host_items,
size_t num_samps
){
- for(size_t i = 0; i < num_samps; i++){
- host_shorts[i] = ntohs(usrp2_shorts[i]);
+ if (is_big_endian){
+ std::memcpy(usrp2_items, host_items, num_samps*sizeof(uint32_t));
+ }
+ else{
+ unrolled_loop(i, num_samps, usrp2_items[i] = htonl(host_items[i]));
}
}
-/***********************************************************************
- * Send Raw Data
- **********************************************************************/
-size_t usrp2_impl::send_raw(
- const boost::asio::const_buffer &buff,
- const uhd::metadata_t &metadata
+static inline void usrp2_items_to_host_items(
+ uint32_t *host_items,
+ const uint32_t *usrp2_items,
+ size_t num_samps
){
- std::vector<boost::asio::const_buffer> buffs(2);
- uint32_t vrt_hdr[max_vrt_header_words];
- uint32_t vrt_hdr_flags = 0;
- size_t num_vrt_hdr_words = 1;
-
- //load the vrt header and flags
- if(metadata.has_stream_id){
- vrt_hdr_flags |= (0x1 << 28); //IF Data packet with Stream Identifier
- vrt_hdr[num_vrt_hdr_words++] = htonl(metadata.stream_id);
+ if (is_big_endian){
+ std::memcpy(host_items, usrp2_items, num_samps*sizeof(uint32_t));
}
- if(metadata.has_time_spec){
- vrt_hdr_flags |= (0x3 << 22) | (0x1 << 20); //TSI: Other, TSF: Sample Count Timestamp
- vrt_hdr[num_vrt_hdr_words++] = htonl(metadata.time_spec.secs);
- vrt_hdr[num_vrt_hdr_words++] = htonl(metadata.time_spec.ticks);
- vrt_hdr[num_vrt_hdr_words++] = 0; //unused part of fractional seconds
+ else{
+ unrolled_loop(i, num_samps, host_items[i] = ntohl(usrp2_items[i]));
}
- vrt_hdr_flags |= (metadata.start_of_burst)? (0x1 << 25) : 0;
- vrt_hdr_flags |= (metadata.end_of_burst)? (0x1 << 24) : 0;
-
- //fill in complete header word
- vrt_hdr[0] = htonl(vrt_hdr_flags |
- ((_stream_id_to_packet_seq[metadata.stream_id]++ & 0xf) << 16) |
- ((boost::asio::buffer_size(buff)/sizeof(uint32_t)) & 0xffff)
- );
-
- //load the buffer vector
- size_t vrt_hdr_size = num_vrt_hdr_words*sizeof(uint32_t);
- buffs[0] = boost::asio::buffer(&vrt_hdr, vrt_hdr_size);
- buffs[1] = buff;
-
- //send and return number of samples
- return (_data_transport->send(buffs) - vrt_hdr_size)/sizeof(sc16_t);
}
/***********************************************************************
* Receive Raw Data
**********************************************************************/
-size_t usrp2_impl::recv_raw(
- const boost::asio::mutable_buffer &buff,
- uhd::metadata_t &metadata
-){
- //load the buffer vector
- std::vector<boost::asio::mutable_buffer> buffs(2);
- uint32_t vrt_hdr[max_vrt_header_words];
- buffs[0] = boost::asio::buffer(vrt_hdr, max_vrt_header_words);
- buffs[1] = buff;
+void usrp2_impl::recv_raw(rx_metadata_t &metadata){
+ //do a receive
+ _rx_smart_buff = _data_transport->recv();
- //receive into the buffers
- size_t bytes_recvd = _data_transport->recv(buffs);
+ //unpack the vrt header
+ size_t num_packet_words32 = asio::buffer_size(_rx_smart_buff->get())/sizeof(uint32_t);
+ if (num_packet_words32 == 0){
+ _rx_copy_buff = boost::asio::buffer("", 0);
+ return; //must exit here after setting the buffer
+ }
+ const uint32_t *vrt_hdr = asio::buffer_cast<const uint32_t *>(_rx_smart_buff->get());
+ size_t num_header_words32_out, num_payload_words32_out, packet_count_out;
+ try{
+ vrt::unpack(
+ metadata, //output
+ vrt_hdr, //input
+ num_header_words32_out, //output
+ num_payload_words32_out, //output
+ num_packet_words32, //input
+ packet_count_out //output
+ );
+ }catch(const std::exception &e){
+ std::cerr << "bad vrt header: " << e.what() << std::endl;
+ _rx_copy_buff = boost::asio::buffer("", 0);
+ return; //must exit here after setting the buffer
+ }
- //failure case
- if (bytes_recvd < max_vrt_header_words*sizeof(uint32_t)) return 0;
+ //handle the packet count / sequence number
+ size_t expected_packet_count = _rx_stream_id_to_packet_seq[metadata.stream_id];
+ if (packet_count_out != expected_packet_count){
+ std::cerr << "bad packet count: " << packet_count_out << std::endl;
+ }
+ _rx_stream_id_to_packet_seq[metadata.stream_id] = (packet_count_out+1)%16;
- //unpack the vrt header
- metadata = uhd::metadata_t();
- uint32_t vrt_header = ntohl(vrt_hdr[0]);
- metadata.has_stream_id = true;
- metadata.stream_id = ntohl(vrt_hdr[1]);
- metadata.has_time_spec = true;
- metadata.time_spec.secs = ntohl(vrt_hdr[2]);
- metadata.time_spec.ticks = ntohl(vrt_hdr[3]);
-
- //return the number of samples received
- size_t num_words = vrt_header & 0xffff;
- return (num_words*sizeof(uint32_t))/sizeof(sc16_t);
+ //setup the rx buffer to point to the data
+ _rx_copy_buff = asio::buffer(
+ vrt_hdr + num_header_words32_out,
+ num_payload_words32_out*sizeof(uint32_t)
+ );
}
/***********************************************************************
* Send Data
**********************************************************************/
size_t usrp2_impl::send(
- const boost::asio::const_buffer &buff,
- const uhd::metadata_t &metadata,
+ const asio::const_buffer &buff,
+ const tx_metadata_t &metadata,
const std::string &type
){
- if (type == "fc32"){
- size_t num_samps = boost::asio::buffer_size(buff)/sizeof(fc32_t);
- boost::shared_array<sc16_t> raw_mem(new sc16_t[num_samps]);
- boost::asio::mutable_buffer raw_buff(raw_mem.get(), num_samps*sizeof(sc16_t));
-
- host_floats_to_usrp2_shorts(
- boost::asio::buffer_cast<int16_t*>(raw_buff),
- boost::asio::buffer_cast<const float*>(buff),
- num_samps*2 //double for complex
- );
-
- return send_raw(raw_buff, metadata);
+ uint32_t tx_mem[_mtu/sizeof(uint32_t)];
+ uint32_t *items = tx_mem + vrt::max_header_words32; //offset for data
+ size_t num_samps = _max_tx_samples_per_packet;
+
+ //calculate the number of samples to be copied
+ //and copy the samples into the send buffer
+ if (type == "32fc"){
+ num_samps = std::min(asio::buffer_size(buff)/sizeof(fc32_t), num_samps);
+ host_floats_to_usrp2_items(items, asio::buffer_cast<const fc32_t*>(buff), num_samps);
+ }
+ else if (type == "16sc"){
+ num_samps = std::min(asio::buffer_size(buff)/sizeof(sc16_t), num_samps);
+ host_items_to_usrp2_items(items, asio::buffer_cast<const uint32_t*>(buff), num_samps);
+ }
+ else{
+ throw std::runtime_error(str(boost::format("usrp2 send: cannot handle type \"%s\"") % type));
}
- if (type == "sc16"){
- #ifdef HAVE_BIG_ENDIAN
- return send_raw(buff, metadata);
- #else
- size_t num_samps = boost::asio::buffer_size(buff)/sizeof(sc16_t);
- boost::shared_array<sc16_t> raw_mem(new sc16_t[num_samps]);
- boost::asio::mutable_buffer raw_buff(raw_mem.get(), num_samps*sizeof(sc16_t));
-
- host_shorts_to_usrp2_shorts(
- boost::asio::buffer_cast<int16_t*>(raw_buff),
- boost::asio::buffer_cast<const int16_t*>(buff),
- num_samps*2 //double for complex
- );
+ uint32_t vrt_hdr[vrt::max_header_words32];
+ size_t num_header_words32, num_packet_words32;
+ size_t packet_count = _tx_stream_id_to_packet_seq[metadata.stream_id]++;
+
+ //pack metadata into a vrt header
+ vrt::pack(
+ metadata, //input
+ vrt_hdr, //output
+ num_header_words32, //output
+ num_samps, //input
+ num_packet_words32, //output
+ packet_count //input
+ );
- return send_raw(raw_buff, metadata);
- #endif
- }
+ //copy in the vrt header (yes we left space)
+ items -= num_header_words32;
+ std::memcpy(items, vrt_hdr, num_header_words32*sizeof(uint32_t));
- throw std::runtime_error(str(boost::format("usrp2 send: cannot handle type \"%s\"") % type));
+ //send and return number of samples
+ _data_transport->send(asio::buffer(items, num_packet_words32*sizeof(uint32_t)));
+ return num_samps;
}
/***********************************************************************
* Receive Data
**********************************************************************/
size_t usrp2_impl::recv(
- const boost::asio::mutable_buffer &buff,
- uhd::metadata_t &metadata,
+ const asio::mutable_buffer &buff,
+ rx_metadata_t &metadata,
const std::string &type
){
- if (type == "fc32"){
- size_t num_samps = boost::asio::buffer_size(buff)/sizeof(fc32_t);
- boost::shared_array<sc16_t> raw_mem(new sc16_t[num_samps]);
- boost::asio::mutable_buffer raw_buff(raw_mem.get(), num_samps*sizeof(sc16_t));
-
- num_samps = recv_raw(raw_buff, metadata);
-
- usrp2_shorts_to_host_floats(
- boost::asio::buffer_cast<float*>(buff),
- boost::asio::buffer_cast<const int16_t*>(raw_buff),
- num_samps*2 //double for complex
- );
-
- return num_samps;
+ //perform a receive if no rx data is waiting to be copied
+ if (asio::buffer_size(_rx_copy_buff) == 0){
+ recv_raw(metadata);
+ }
+ //otherwise flag the metadata to show that is is a fragment
+ else{
+ metadata = rx_metadata_t();
+ metadata.is_fragment = true;
}
- if (type == "sc16"){
- #ifdef HAVE_BIG_ENDIAN
- return recv_raw(buff, metadata);
- #else
- size_t num_samps = boost::asio::buffer_size(buff)/sizeof(sc16_t);
- boost::shared_array<sc16_t> raw_mem(new sc16_t[num_samps]);
- boost::asio::mutable_buffer raw_buff(raw_mem.get(), num_samps*sizeof(sc16_t));
-
- num_samps = recv_raw(raw_buff, metadata);
-
- usrp2_shorts_to_host_shorts(
- boost::asio::buffer_cast<int16_t*>(buff),
- boost::asio::buffer_cast<const int16_t*>(raw_buff),
- num_samps*2 //double for complex
- );
-
- return num_samps;
- #endif
+ //extract the number of samples available to copy
+ //and a pointer into the usrp2 received items memory
+ size_t bytes_to_copy = asio::buffer_size(_rx_copy_buff);
+ if (bytes_to_copy == 0) return 0; //nothing to receive
+ size_t num_samps = bytes_to_copy/sizeof(uint32_t);
+ const uint32_t *items = asio::buffer_cast<const uint32_t*>(_rx_copy_buff);
+
+ //calculate the number of samples to be copied
+ //and copy the samples from the recv buffer
+ if (type == "32fc"){
+ num_samps = std::min(asio::buffer_size(buff)/sizeof(fc32_t), num_samps);
+ usrp2_items_to_host_floats(asio::buffer_cast<fc32_t*>(buff), items, num_samps);
+ }
+ else if (type == "16sc"){
+ num_samps = std::min(asio::buffer_size(buff)/sizeof(sc16_t), num_samps);
+ usrp2_items_to_host_items(asio::buffer_cast<uint32_t*>(buff), items, num_samps);
}
+ else{
+ throw std::runtime_error(str(boost::format("usrp2 recv: cannot handle type \"%s\"") % type));
+ }
+
+ //update the rx copy buffer to reflect the bytes copied
+ _rx_copy_buff = asio::buffer(
+ items + num_samps, bytes_to_copy - num_samps*sizeof(uint32_t)
+ );
- throw std::runtime_error(str(boost::format("usrp2 recv: cannot handle type \"%s\"") % type));
+ return num_samps;
}
diff --git a/host/lib/usrp/usrp2/mboard_impl.cpp b/host/lib/usrp/usrp2/mboard_impl.cpp
index cc73b229c..4b15c7f3e 100644
--- a/host/lib/usrp/usrp2/mboard_impl.cpp
+++ b/host/lib/usrp/usrp2/mboard_impl.cpp
@@ -16,6 +16,7 @@
//
#include <uhd/utils.hpp>
+#include <boost/assign/list_of.hpp>
#include "usrp2_impl.hpp"
using namespace uhd;
@@ -28,6 +29,10 @@ void usrp2_impl::mboard_init(void){
boost::bind(&usrp2_impl::mboard_get, this, _1, _2),
boost::bind(&usrp2_impl::mboard_set, this, _1, _2)
);
+
+ //set the time on the usrp2 as close as possible to the system utc time
+ boost::posix_time::ptime now(boost::posix_time::microsec_clock::universal_time());
+ set_time_spec(time_spec_t(now, get_master_clock_freq()), true);
}
void usrp2_impl::init_clock_config(void){
@@ -64,6 +69,19 @@ void usrp2_impl::update_clock_config(void){
ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_GOT_THE_NEW_CLOCK_CONFIG_DUDE);
}
+void usrp2_impl::set_time_spec(const time_spec_t &time_spec, bool now){
+ //setup the out data
+ usrp2_ctrl_data_t out_data;
+ out_data.id = htonl(USRP2_CTRL_ID_GOT_A_NEW_TIME_FOR_YOU_BRO);
+ out_data.data.time_args.secs = htonl(time_spec.secs);
+ out_data.data.time_args.ticks = htonl(time_spec.ticks);
+ out_data.data.time_args.now = (now)? 1 : 0;
+
+ //send and recv
+ usrp2_ctrl_data_t in_data = ctrl_send_and_recv(out_data);
+ ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_SWEET_I_GOT_THAT_TIME_DUDE);
+}
+
/***********************************************************************
* MBoard Get Properties
**********************************************************************/
@@ -71,17 +89,54 @@ void usrp2_impl::mboard_get(const wax::obj &key_, wax::obj &val){
wax::obj key; std::string name;
boost::tie(key, name) = extract_named_prop(key_);
+ //handle the other props
+ if (key.type() == typeid(std::string)){
+ if (key.as<std::string>() == "mac-addr"){
+ //setup the out data
+ usrp2_ctrl_data_t out_data;
+ out_data.id = htonl(USRP2_CTRL_ID_GIVE_ME_YOUR_MAC_ADDR_BRO);
+
+ //send and recv
+ usrp2_ctrl_data_t in_data = ctrl_send_and_recv(out_data);
+ ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_THIS_IS_MY_MAC_ADDR_DUDE);
+
+ //extract the address
+ val = reinterpret_cast<mac_addr_t*>(in_data.data.mac_addr)->to_string();
+ return;
+ }
+
+ if (key.as<std::string>() == "ip-addr"){
+ //setup the out data
+ usrp2_ctrl_data_t out_data;
+ out_data.id = htonl(USRP2_CTRL_ID_GIVE_ME_YOUR_IP_ADDR_BRO);
+
+ //send and recv
+ usrp2_ctrl_data_t in_data = ctrl_send_and_recv(out_data);
+ ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_THIS_IS_MY_IP_ADDR_DUDE);
+
+ //extract the address
+ val = boost::asio::ip::address_v4(ntohl(in_data.data.ip_addr)).to_string();
+ return;
+ }
+ }
+
//handle the get request conditioned on the key
- switch(wax::cast<mboard_prop_t>(key)){
+ switch(key.as<mboard_prop_t>()){
case MBOARD_PROP_NAME:
val = std::string("usrp2 mboard");
return;
- case MBOARD_PROP_OTHERS:
- val = prop_names_t(); //empty other props
+ case MBOARD_PROP_OTHERS:{
+ prop_names_t others = boost::assign::list_of
+ ("mac-addr")
+ ("ip-addr")
+ ;
+ val = others;
+ }
return;
case MBOARD_PROP_RX_DBOARD:
+ ASSERT_THROW(_rx_dboards.has_key(name));
val = _rx_dboards[name].get_link();
return;
@@ -90,6 +145,7 @@ void usrp2_impl::mboard_get(const wax::obj &key_, wax::obj &val){
return;
case MBOARD_PROP_TX_DBOARD:
+ ASSERT_THROW(_tx_dboards.has_key(name));
val = _tx_dboards[name].get_link();
return;
@@ -97,17 +153,12 @@ void usrp2_impl::mboard_get(const wax::obj &key_, wax::obj &val){
val = prop_names_t(_tx_dboards.get_keys());
return;
- case MBOARD_PROP_MTU:
- // FIXME we dont know the real MTU...
- // give them something to fragment about
- val = size_t(1500);
- return;
-
case MBOARD_PROP_CLOCK_RATE:
val = freq_t(get_master_clock_freq());
return;
case MBOARD_PROP_RX_DSP:
+ ASSERT_THROW(_rx_dsps.has_key(name));
val = _rx_dsps[name].get_link();
return;
@@ -116,6 +167,7 @@ void usrp2_impl::mboard_get(const wax::obj &key_, wax::obj &val){
return;
case MBOARD_PROP_TX_DSP:
+ ASSERT_THROW(_tx_dsps.has_key(name));
val = _tx_dsps[name].get_link();
return;
@@ -154,36 +206,73 @@ void usrp2_impl::mboard_get(const wax::obj &key_, wax::obj &val){
* MBoard Set Properties
**********************************************************************/
void usrp2_impl::mboard_set(const wax::obj &key, const wax::obj &val){
+ //handle the other props
+ if (key.type() == typeid(std::string)){
+ if (key.as<std::string>() == "mac-addr"){
+ //setup the out data
+ usrp2_ctrl_data_t out_data;
+ out_data.id = htonl(USRP2_CTRL_ID_HERE_IS_A_NEW_MAC_ADDR_BRO);
+ mac_addr_t mac_addr(val.as<std::string>());
+ std::memcpy(out_data.data.mac_addr, &mac_addr, sizeof(mac_addr_t));
+
+ //send and recv
+ usrp2_ctrl_data_t in_data = ctrl_send_and_recv(out_data);
+ ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_THIS_IS_MY_MAC_ADDR_DUDE);
+ return;
+ }
+
+ if (key.as<std::string>() == "ip-addr"){
+ //setup the out data
+ usrp2_ctrl_data_t out_data;
+ out_data.id = htonl(USRP2_CTRL_ID_HERE_IS_A_NEW_IP_ADDR_BRO);
+ out_data.data.ip_addr = htonl(boost::asio::ip::address_v4::from_string(val.as<std::string>()).to_ulong());
+
+ //send and recv
+ usrp2_ctrl_data_t in_data = ctrl_send_and_recv(out_data);
+ ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_THIS_IS_MY_IP_ADDR_DUDE);
+ return;
+ }
+ }
+
//handle the get request conditioned on the key
- switch(wax::cast<mboard_prop_t>(key)){
+ switch(key.as<mboard_prop_t>()){
case MBOARD_PROP_PPS_SOURCE:{
- std::string name = wax::cast<std::string>(val);
- ASSERT_THROW(_pps_source_dict.has_key(name));
+ std::string name = val.as<std::string>();
+ assert_has(_pps_source_dict.get_keys(), name, "usrp2 pps source");
_pps_source = name; //shadow
update_clock_config();
}
return;
case MBOARD_PROP_PPS_POLARITY:{
- std::string name = wax::cast<std::string>(val);
- ASSERT_THROW(_pps_polarity_dict.has_key(name));
+ std::string name = val.as<std::string>();
+ assert_has(_pps_polarity_dict.get_keys(), name, "usrp2 pps polarity");
_pps_polarity = name; //shadow
update_clock_config();
}
return;
case MBOARD_PROP_REF_SOURCE:{
- std::string name = wax::cast<std::string>(val);
- ASSERT_THROW(_ref_source_dict.has_key(name));
+ std::string name = val.as<std::string>();
+ assert_has(_ref_source_dict.get_keys(), name, "usrp2 reference source");
_ref_source = name; //shadow
update_clock_config();
}
return;
+ case MBOARD_PROP_TIME_NOW:{
+ set_time_spec(val.as<time_spec_t>(), true);
+ return;
+ }
+
+ case MBOARD_PROP_TIME_NEXT_PPS:{
+ set_time_spec(val.as<time_spec_t>(), false);
+ return;
+ }
+
case MBOARD_PROP_NAME:
case MBOARD_PROP_OTHERS:
- case MBOARD_PROP_MTU:
case MBOARD_PROP_CLOCK_RATE:
case MBOARD_PROP_RX_DSP:
case MBOARD_PROP_RX_DSP_NAMES:
@@ -195,8 +284,6 @@ void usrp2_impl::mboard_set(const wax::obj &key, const wax::obj &val){
case MBOARD_PROP_TX_DBOARD_NAMES:
case MBOARD_PROP_PPS_SOURCE_NAMES:
case MBOARD_PROP_REF_SOURCE_NAMES:
- case MBOARD_PROP_TIME_NOW:
- case MBOARD_PROP_TIME_NEXT_PPS:
throw std::runtime_error("Error: trying to set read-only property on usrp2 mboard");
}
diff --git a/host/lib/usrp/usrp2/usrp2_impl.cpp b/host/lib/usrp/usrp2/usrp2_impl.cpp
index 5aa5d6e8d..e1371a094 100644
--- a/host/lib/usrp/usrp2/usrp2_impl.cpp
+++ b/host/lib/usrp/usrp2/usrp2_impl.cpp
@@ -23,6 +23,12 @@
using namespace uhd;
using namespace uhd::usrp;
+using namespace uhd::transport;
+namespace asio = boost::asio;
+
+STATIC_BLOCK(register_usrp2_device){
+ device::register_device(&usrp2::discover, &usrp2::make);
+}
/***********************************************************************
* Discovery over the udp transport
@@ -30,30 +36,26 @@ using namespace uhd::usrp;
uhd::device_addrs_t usrp2::discover(const device_addr_t &hint){
device_addrs_t usrp2_addrs;
+ if (not hint.has_key("addr")) return usrp2_addrs;
+
//create a udp transport to communicate
//TODO if an addr is not provided, search all interfaces?
std::string ctrl_port = boost::lexical_cast<std::string>(USRP2_UDP_CTRL_PORT);
- transport::udp::sptr udp_transport = \
- transport::udp::make(hint["addr"], ctrl_port, true);
+ udp_simple::sptr udp_transport = udp_simple::make_broadcast(
+ hint["addr"], ctrl_port
+ );
//send a hello control packet
usrp2_ctrl_data_t ctrl_data_out;
ctrl_data_out.id = htonl(USRP2_CTRL_ID_GIVE_ME_YOUR_IP_ADDR_BRO);
udp_transport->send(boost::asio::buffer(&ctrl_data_out, sizeof(ctrl_data_out)));
- //loop and recieve until the time is up
- size_t num_timeouts = 0;
+ //loop and recieve until the timeout
while(true){
usrp2_ctrl_data_t ctrl_data_in;
- size_t len = udp_transport->recv(
- boost::asio::buffer(&ctrl_data_in, sizeof(ctrl_data_in))
- );
+ size_t len = udp_transport->recv(asio::buffer(&ctrl_data_in, sizeof(ctrl_data_in)));
//std::cout << len << "\n";
- if (len < sizeof(usrp2_ctrl_data_t)){
- //sleep a little so we dont burn cpu
- if (num_timeouts++ > 50) break;
- boost::this_thread::sleep(boost::posix_time::milliseconds(1));
- }else{
+ if (len >= sizeof(usrp2_ctrl_data_t)){
//handle the received data
switch(ntohl(ctrl_data_in.id)){
case USRP2_CTRL_ID_THIS_IS_MY_IP_ADDR_DUDE:
@@ -61,12 +63,14 @@ uhd::device_addrs_t usrp2::discover(const device_addr_t &hint){
boost::asio::ip::address_v4 ip_addr(ntohl(ctrl_data_in.data.ip_addr));
device_addr_t new_addr;
new_addr["name"] = "USRP2";
- new_addr["type"] = "usrp2";
+ new_addr["transport"] = "udp";
new_addr["addr"] = ip_addr.to_string();
usrp2_addrs.push_back(new_addr);
- break;
+ //dont break here, it will exit the while loop
+ //just continue on to the next loop iteration
}
}
+ if (len == 0) break; //timeout
}
return usrp2_addrs;
@@ -75,16 +79,18 @@ uhd::device_addrs_t usrp2::discover(const device_addr_t &hint){
/***********************************************************************
* Make
**********************************************************************/
-#define num2str(num) (boost::lexical_cast<std::string>(num))
+template <class T> std::string num2str(T num){
+ return boost::lexical_cast<std::string>(num);
+}
device::sptr usrp2::make(const device_addr_t &device_addr){
//create a control transport
- transport::udp::sptr ctrl_transport = transport::udp::make(
+ udp_simple::sptr ctrl_transport = udp_simple::make_connected(
device_addr["addr"], num2str(USRP2_UDP_CTRL_PORT)
);
//create a data transport
- transport::udp::sptr data_transport = transport::udp::make(
+ udp_zero_copy::sptr data_transport = udp_zero_copy::make(
device_addr["addr"], num2str(USRP2_UDP_DATA_PORT)
);
@@ -98,8 +104,8 @@ device::sptr usrp2::make(const device_addr_t &device_addr){
* Structors
**********************************************************************/
usrp2_impl::usrp2_impl(
- transport::udp::sptr ctrl_transport,
- transport::udp::sptr data_transport
+ udp_simple::sptr ctrl_transport,
+ udp_zero_copy::sptr data_transport
){
_ctrl_transport = ctrl_transport;
_data_transport = data_transport;
@@ -132,9 +138,8 @@ usrp2_impl::usrp2_impl(
//init the tx and rx dboards (do last)
dboard_init();
- //send a small data packet so the usrp2 knows the udp source port
- uint32_t zero_data = 0;
- _data_transport->send(boost::asio::buffer(&zero_data, sizeof(zero_data)));
+ //init the send and recv io
+ io_init();
}
@@ -160,24 +165,15 @@ usrp2_ctrl_data_t usrp2_impl::ctrl_send_and_recv(const usrp2_ctrl_data_t &out_da
out_copy.seq = htonl(++_ctrl_seq_num);
_ctrl_transport->send(boost::asio::buffer(&out_copy, sizeof(usrp2_ctrl_data_t)));
- //loop and recieve until the time is up
- size_t num_timeouts = 0;
+ //loop until we get the packet or timeout
while(true){
usrp2_ctrl_data_t in_data;
- size_t len = _ctrl_transport->recv(
- boost::asio::buffer(&in_data, sizeof(in_data))
- );
- if (len < sizeof(usrp2_ctrl_data_t)){
- //sleep a little so we dont burn cpu
- if (num_timeouts++ > 50) break;
- boost::this_thread::sleep(boost::posix_time::milliseconds(1));
- }else{
- //handle the received data
- if (ntohl(in_data.seq) == _ctrl_seq_num){
- return in_data;
- }
- //didnt get seq, continue on...
+ size_t len = _ctrl_transport->recv(asio::buffer(&in_data, sizeof(in_data)));
+ if (len >= sizeof(usrp2_ctrl_data_t) and ntohl(in_data.seq) == _ctrl_seq_num){
+ return in_data;
}
+ if (len == 0) break; //timeout
+ //didnt get seq or bad packet, continue looking...
}
throw std::runtime_error("usrp2 no control response");
}
@@ -190,18 +186,28 @@ void usrp2_impl::get(const wax::obj &key_, wax::obj &val){
boost::tie(key, name) = extract_named_prop(key_);
//handle the get request conditioned on the key
- switch(wax::cast<device_prop_t>(key)){
+ switch(key.as<device_prop_t>()){
case DEVICE_PROP_NAME:
val = std::string("usrp2 device");
return;
case DEVICE_PROP_MBOARD:
+ ASSERT_THROW(_mboards.has_key(name));
val = _mboards[name].get_link();
return;
case DEVICE_PROP_MBOARD_NAMES:
val = prop_names_t(_mboards.get_keys());
return;
+
+ case DEVICE_PROP_MAX_RX_SAMPLES:
+ val = size_t(_max_rx_samples_per_packet);
+ return;
+
+ case DEVICE_PROP_MAX_TX_SAMPLES:
+ val = size_t(_max_tx_samples_per_packet);
+ return;
+
}
}
diff --git a/host/lib/usrp/usrp2/usrp2_impl.hpp b/host/lib/usrp/usrp2/usrp2_impl.hpp
index 9a4c42d42..fc713c2bf 100644
--- a/host/lib/usrp/usrp2/usrp2_impl.hpp
+++ b/host/lib/usrp/usrp2/usrp2_impl.hpp
@@ -22,7 +22,9 @@
#include <boost/thread.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/function.hpp>
-#include <uhd/transport/udp.hpp>
+#include <uhd/transport/vrt.hpp>
+#include <uhd/transport/udp_simple.hpp>
+#include <uhd/transport/udp_zero_copy.hpp>
#include <uhd/usrp/dboard_manager.hpp>
#include "fw_common.h"
@@ -81,8 +83,8 @@ public:
* \param data_transport the udp transport for data
*/
usrp2_impl(
- uhd::transport::udp::sptr ctrl_transport,
- uhd::transport::udp::sptr data_transport
+ uhd::transport::udp_simple::sptr ctrl_transport,
+ uhd::transport::udp_zero_copy::sptr data_transport
);
~usrp2_impl(void);
@@ -98,18 +100,32 @@ public:
double get_master_clock_freq(void);
//the io interface
- size_t send(const boost::asio::const_buffer &, const uhd::metadata_t &, const std::string &);
- size_t recv(const boost::asio::mutable_buffer &, uhd::metadata_t &, const std::string &);
+ size_t send(const boost::asio::const_buffer &, const uhd::tx_metadata_t &, const std::string &);
+ size_t recv(const boost::asio::mutable_buffer &, uhd::rx_metadata_t &, const std::string &);
private:
//the raw io interface (samples are in the usrp2 native format)
- size_t send_raw(const boost::asio::const_buffer &, const uhd::metadata_t &);
- size_t recv_raw(const boost::asio::mutable_buffer &, uhd::metadata_t &);
- uhd::dict<uint32_t, size_t> _stream_id_to_packet_seq;
+ void recv_raw(uhd::rx_metadata_t &);
+ uhd::dict<uint32_t, size_t> _tx_stream_id_to_packet_seq;
+ uhd::dict<uint32_t, size_t> _rx_stream_id_to_packet_seq;
+ static const size_t _mtu = 1500; //FIXME we have no idea
+ static const size_t _hdrs = (2 + 14 + 20 + 8); //size of headers (pad, eth, ip, udp)
+ static const size_t _max_rx_samples_per_packet =
+ (_mtu - _hdrs)/sizeof(uint32_t) -
+ USRP2_HOST_RX_VRT_HEADER_WORDS32 -
+ USRP2_HOST_RX_VRT_TRAILER_WORDS32
+ ;
+ static const size_t _max_tx_samples_per_packet =
+ (_mtu - _hdrs)/sizeof(uint32_t) -
+ uhd::transport::vrt::max_header_words32
+ ;
+ uhd::transport::smart_buffer::sptr _rx_smart_buff;
+ boost::asio::const_buffer _rx_copy_buff;
+ void io_init(void);
//udp transports for control and data
- uhd::transport::udp::sptr _ctrl_transport;
- uhd::transport::udp::sptr _data_transport;
+ uhd::transport::udp_simple::sptr _ctrl_transport;
+ uhd::transport::udp_zero_copy::sptr _data_transport;
//private vars for dealing with send/recv control
uint32_t _ctrl_seq_num;
@@ -119,6 +135,7 @@ private:
std::string _pps_source, _pps_polarity, _ref_source;
void init_clock_config(void);
void update_clock_config(void);
+ void set_time_spec(const uhd::time_spec_t &time_spec, bool now);
//mappings from clock config strings to over the wire enums
uhd::dict<std::string, usrp2_pps_source_t> _pps_source_dict;
generated by cgit v1.2.3 (git 2.46.0) at 2025-11-04 00:08:21 +0000