aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--firmware/microblaze/apps/Makefile.am2
-rw-r--r--firmware/microblaze/apps/txrx.c89
-rw-r--r--host/CMakeLists.txt9
-rw-r--r--host/apps/discover_usrps.cpp29
-rw-r--r--host/include/uhd/CMakeLists.txt2
-rw-r--r--host/include/uhd/device.hpp37
-rw-r--r--host/include/uhd/device_addr.hpp4
-rw-r--r--host/include/uhd/metadata.hpp51
-rw-r--r--host/include/uhd/shared_iovec.hpp54
-rw-r--r--host/include/uhd/transport/udp.hpp39
-rw-r--r--host/include/uhd/usrp/CMakeLists.txt1
-rw-r--r--host/include/uhd/usrp/usrp1e.hpp48
-rw-r--r--host/include/uhd/usrp/usrp2.hpp6
-rw-r--r--host/lib/CMakeLists.txt16
-rw-r--r--host/lib/device.cpp105
-rw-r--r--host/lib/device_addr.cpp4
-rw-r--r--host/lib/transport/udp.cpp69
-rw-r--r--host/lib/usrp/dboard_manager.cpp27
-rw-r--r--host/lib/usrp/usrp1e/usrp1e_none.cpp (renamed from host/lib/shared_iovec.cpp)20
-rw-r--r--host/lib/usrp/usrp2/io_impl.cpp242
-rw-r--r--host/lib/usrp/usrp2/usrp2_impl.cpp72
-rw-r--r--host/lib/usrp/usrp2/usrp2_impl.hpp9
22 files changed, 708 insertions, 227 deletions
diff --git a/firmware/microblaze/apps/Makefile.am b/firmware/microblaze/apps/Makefile.am
index 6d993ef8c..ff426cf8c 100644
--- a/firmware/microblaze/apps/Makefile.am
+++ b/firmware/microblaze/apps/Makefile.am
@@ -21,7 +21,7 @@ include $(top_srcdir)/Makefile.common
LDADD = $(top_srcdir)/lib/libu2fw.a
-AM_CFLAGS += -I$(top_srcdir)/../../host/lib/usrp/mboard
+AM_CFLAGS += -I$(top_srcdir)/../../host/lib/usrp
noinst_PROGRAMS = txrx.elf
diff --git a/firmware/microblaze/apps/txrx.c b/firmware/microblaze/apps/txrx.c
index 77c8e498c..1724284b0 100644
--- a/firmware/microblaze/apps/txrx.c
+++ b/firmware/microblaze/apps/txrx.c
@@ -47,6 +47,8 @@
#include <i2c.h>
#include <lsdac.h>
#include <lsadc.h>
+#include <ethertype.h>
+#include <arp_cache.h>
#define FW_SETS_SEQNO 1 // define to 0 or 1 (FIXME must be 1 for now)
@@ -136,10 +138,14 @@ static int streaming_frame_count = 0;
bool is_streaming(void){ return streaming_p; }
-
// ----------------------------------------------------------------
+// the fast-path setup global variables
+// ----------------------------------------------------------------
+static eth_mac_addr_t fp_mac_addr_src, fp_mac_addr_dst;
+static struct socket_address fp_socket_src, fp_socket_dst;
-void start_rx_streaming_cmd(void *p);
+// ----------------------------------------------------------------
+void start_rx_streaming_cmd(void);
void stop_rx_cmd(void);
static eth_mac_addr_t get_my_eth_mac_addr(void){
@@ -158,8 +164,38 @@ void handle_udp_data_packet(
struct socket_address src, struct socket_address dst,
unsigned char *payload, int payload_len
){
- //TODO store the reply port
- _is_data = true;
+ //forward this data to the dsp when the payload is sufficient
+ //the small payload is used to give the device the udp source port
+ if (payload_len > sizeof(uint32_t)){
+ _is_data = true;
+ return;
+ }
+
+ //its a tiny payload, load the fast-path variables
+ fp_mac_addr_src = get_my_eth_mac_addr();
+ arp_cache_lookup_mac(&src.addr, &fp_mac_addr_dst);
+ fp_socket_src = dst;
+ fp_socket_dst = src;
+ printf("Storing for fast path:\n");
+ printf(" source mac addr: ");
+ print_mac_addr(fp_mac_addr_src.addr); newline();
+ printf(" source ip addr: %d.%d.%d.%d\n",
+ ((const unsigned char*)&fp_socket_src.addr.addr)[0],
+ ((const unsigned char*)&fp_socket_src.addr.addr)[1],
+ ((const unsigned char*)&fp_socket_src.addr.addr)[2],
+ ((const unsigned char*)&fp_socket_src.addr.addr)[3]
+ );
+ printf(" source udp port: %d\n", fp_socket_src.port);
+ printf(" destination mac addr: ");
+ print_mac_addr(fp_mac_addr_dst.addr); newline();
+ printf(" destination ip addr: %d.%d.%d.%d\n",
+ ((const unsigned char*)&fp_socket_dst.addr.addr)[0],
+ ((const unsigned char*)&fp_socket_dst.addr.addr)[1],
+ ((const unsigned char*)&fp_socket_dst.addr.addr)[2],
+ ((const unsigned char*)&fp_socket_dst.addr.addr)[3]
+ );
+ printf(" destination udp port: %d\n", fp_socket_dst.port);
+ newline();
}
#define OTW_GPIO_BANK_TO_NUM(bank) \
@@ -423,7 +459,7 @@ void handle_udp_ctrl_packet(
stop_rx_cmd();
}
else{
- start_rx_streaming_cmd(NULL);
+ start_rx_streaming_cmd();
}
ctrl_data_out.id = USRP2_CTRL_ID_CONFIGURED_THAT_STREAMING_DUDE;
@@ -480,7 +516,7 @@ eth_pkt_inspector(dbsm_t *sm, int bufno)
//------------------------------------------------------------------
#define VRT_HEADER_WORDS 5
-#define VRT_TRAILER_WORDS 1
+#define VRT_TRAILER_WORDS 0
void
restart_streaming(void)
@@ -491,7 +527,7 @@ restart_streaming(void)
sr_rx_ctrl->clear_overrun = 1; // reset
sr_rx_ctrl->vrt_header = (0
| VRTH_PT_IF_DATA_WITH_SID
- | VRTH_HAS_TRAILER
+ | ((VRT_TRAILER_WORDS)? VRTH_HAS_TRAILER : 0)
| VRTH_TSI_OTHER
| VRTH_TSF_SAMPLE_CNT
| (VRT_HEADER_WORDS+streaming_items_per_frame+VRT_TRAILER_WORDS));
@@ -524,14 +560,14 @@ restart_streaming(void)
*
* init chksum to zero to start.
*/
-/*static unsigned int
+static unsigned int
CHKSUM(unsigned int x, unsigned int *chksum)
{
*chksum += x;
*chksum = (*chksum & 0xffff) + (*chksum>>16);
*chksum = (*chksum & 0xffff) + (*chksum>>16);
return x;
-}*/
+}
/*
* Called when eth phy state changes (w/ interrupts disabled)
@@ -546,7 +582,7 @@ link_changed_callback(int speed)
}
void
-start_rx_streaming_cmd(void *p)
+start_rx_streaming_cmd(void)
{
/*
* Construct ethernet header and preload into two buffers
@@ -556,31 +592,31 @@ start_rx_streaming_cmd(void *p)
} mem _AL4;
memset(&mem, 0, sizeof(mem));
- //p->items_per_frame = (1500)/sizeof(uint32_t) - (DSP_TX_FIRST_LINE + VRT_HEADER_WORDS + VRT_TRAILER_WORDS); //FIXME
- //mem.ctrl_word = (VRT_HEADER_WORDS+p->items_per_frame+VRT_TRAILER_WORDS)*sizeof(uint32_t) | 1 << 16;
+ streaming_items_per_frame = (1500)/sizeof(uint32_t) - (DSP_TX_FIRST_LINE + VRT_HEADER_WORDS + VRT_TRAILER_WORDS); //FIXME
+ mem.ctrl_word = (VRT_HEADER_WORDS+streaming_items_per_frame+VRT_TRAILER_WORDS)*sizeof(uint32_t) | 1 << 16;
memcpy_wa(buffer_ram(DSP_RX_BUF_0), &mem, sizeof(mem));
memcpy_wa(buffer_ram(DSP_RX_BUF_1), &mem, sizeof(mem));
//setup ethernet header machine
- /*sr_udp_sm->eth_hdr.mac_dst_0_1 = (host_dst_mac_addr.addr[0] << 8) | host_dst_mac_addr.addr[1];
- sr_udp_sm->eth_hdr.mac_dst_2_3 = (host_dst_mac_addr.addr[2] << 8) | host_dst_mac_addr.addr[3];
- sr_udp_sm->eth_hdr.mac_dst_4_5 = (host_dst_mac_addr.addr[4] << 8) | host_dst_mac_addr.addr[5];
- sr_udp_sm->eth_hdr.mac_src_0_1 = (host_src_mac_addr.addr[0] << 8) | host_src_mac_addr.addr[1];
- sr_udp_sm->eth_hdr.mac_src_2_3 = (host_src_mac_addr.addr[2] << 8) | host_src_mac_addr.addr[3];
- sr_udp_sm->eth_hdr.mac_src_4_5 = (host_src_mac_addr.addr[4] << 8) | host_src_mac_addr.addr[5];
- sr_udp_sm->eth_hdr.ether_type = ETHERTYPE_IPV4;*/
+ sr_udp_sm->eth_hdr.mac_dst_0_1 = (fp_mac_addr_dst.addr[0] << 8) | fp_mac_addr_dst.addr[1];
+ sr_udp_sm->eth_hdr.mac_dst_2_3 = (fp_mac_addr_dst.addr[2] << 8) | fp_mac_addr_dst.addr[3];
+ sr_udp_sm->eth_hdr.mac_dst_4_5 = (fp_mac_addr_dst.addr[4] << 8) | fp_mac_addr_dst.addr[5];
+ sr_udp_sm->eth_hdr.mac_src_0_1 = (fp_mac_addr_src.addr[0] << 8) | fp_mac_addr_src.addr[1];
+ sr_udp_sm->eth_hdr.mac_src_2_3 = (fp_mac_addr_src.addr[2] << 8) | fp_mac_addr_src.addr[3];
+ sr_udp_sm->eth_hdr.mac_src_4_5 = (fp_mac_addr_src.addr[4] << 8) | fp_mac_addr_src.addr[5];
+ sr_udp_sm->eth_hdr.ether_type = ETHERTYPE_IPV4;
//setup ip header machine
- /*unsigned int chksum = 0;
+ unsigned int chksum = 0;
sr_udp_sm->ip_hdr.ver_ihl_tos = CHKSUM(0x4500, &chksum); // IPV4, 5 words of header (20 bytes), TOS=0
sr_udp_sm->ip_hdr.total_length = UDP_SM_INS_IP_LEN; // Don't checksum this line in SW
sr_udp_sm->ip_hdr.identification = CHKSUM(0x0000, &chksum); // ID
sr_udp_sm->ip_hdr.flags_frag_off = CHKSUM(0x4000, &chksum); // don't fragment
sr_udp_sm->ip_hdr.ttl_proto = CHKSUM(0x2011, &chksum); // TTL=32, protocol = UDP (17 decimal)
//sr_udp_sm->ip_hdr.checksum .... filled in below
- uint32_t src_ip_addr = host_src_ip_addr.s_addr;
- uint32_t dst_ip_addr = host_dst_ip_addr.s_addr;
+ uint32_t src_ip_addr = fp_socket_src.addr.addr;
+ uint32_t dst_ip_addr = fp_socket_dst.addr.addr;
sr_udp_sm->ip_hdr.src_addr_high = CHKSUM(src_ip_addr >> 16, &chksum); // IP src high
sr_udp_sm->ip_hdr.src_addr_low = CHKSUM(src_ip_addr & 0xffff, &chksum); // IP src low
sr_udp_sm->ip_hdr.dst_addr_high = CHKSUM(dst_ip_addr >> 16, &chksum); // IP dst high
@@ -588,17 +624,14 @@ start_rx_streaming_cmd(void *p)
sr_udp_sm->ip_hdr.checksum = UDP_SM_INS_IP_HDR_CHKSUM | (chksum & 0xffff);
//setup the udp header machine
- sr_udp_sm->udp_hdr.src_port = host_src_udp_port;
- sr_udp_sm->udp_hdr.dst_port = host_dst_udp_port;
+ sr_udp_sm->udp_hdr.src_port = fp_socket_src.port;
+ sr_udp_sm->udp_hdr.dst_port = fp_socket_dst.port;
sr_udp_sm->udp_hdr.length = UDP_SM_INS_UDP_LEN;
- sr_udp_sm->udp_hdr.checksum = UDP_SM_LAST_WORD; // zero UDP checksum*/
+ sr_udp_sm->udp_hdr.checksum = UDP_SM_LAST_WORD; // zero UDP checksum
if (FW_SETS_SEQNO)
fw_seqno = 0;
- //streaming_items_per_frame = p->items_per_frame;
- //time_secs = p->time_secs;
- //time_ticks = p->time_ticks;
restart_streaming();
}
diff --git a/host/CMakeLists.txt b/host/CMakeLists.txt
index 70c04631b..30f4789a3 100644
--- a/host/CMakeLists.txt
+++ b/host/CMakeLists.txt
@@ -73,6 +73,15 @@ INCLUDE_DIRECTORIES(${Boost_INCLUDE_DIRS})
LINK_DIRECTORIES(${Boost_LIBRARY_DIRS})
########################################################################
+# Setup Endianess
+########################################################################
+INCLUDE(TestBigEndian)
+TEST_BIG_ENDIAN(HAVE_BIG_ENDIAN)
+IF(HAVE_BIG_ENDIAN)
+ ADD_DEFINITIONS("-DHAVE_BIG_ENDIAN=/* */")
+ENDIF(HAVE_BIG_ENDIAN)
+
+########################################################################
# Create Uninstall Target
########################################################################
CONFIGURE_FILE(
diff --git a/host/apps/discover_usrps.cpp b/host/apps/discover_usrps.cpp
index 02c05b7cc..7e8c21673 100644
--- a/host/apps/discover_usrps.cpp
+++ b/host/apps/discover_usrps.cpp
@@ -22,13 +22,13 @@
#include <iostream>
namespace po = boost::program_options;
-using namespace uhd;
int main(int argc, char *argv[]){
po::options_description desc("Allowed options");
desc.add_options()
("help", "help message")
- ("ip-addr", po::value<std::string>(), "usrp2 ip address")
+ ("addr", po::value<std::string>(), "resolvable network address")
+ ("node", po::value<std::string>(), "path to linux device node")
;
po::variables_map vm;
@@ -36,30 +36,35 @@ int main(int argc, char *argv[]){
po::notify(vm);
//print the help message
- if (vm.count("help")) {
+ if (vm.count("help")){
std::cout << boost::format("Discover USRPs %s") % desc << std::endl;
return ~0;
}
- //extract the ip address (not optional for now)
+ //load the options into the address
uhd::device_addr_t device_addr;
- device_addr["type"] = "udp";
- if (vm.count("ip-addr")) {
- device_addr["addr"] = vm["ip-addr"].as<std::string>();
- } else {
- std::cout << "IP Addess was not set" << std::endl;
+ if (vm.count("addr")){
+ device_addr["addr"] = vm["addr"].as<std::string>();
+ }
+ if (vm.count("node")){
+ device_addr["node"] = vm["node"].as<std::string>();
+ }
+
+ //discover the usrps and print the results
+ uhd::device_addrs_t device_addrs = uhd::device::discover(device_addr);
+
+ if (device_addrs.size() == 0){
+ std::cerr << "No USRP Devices Found" << std::endl;
return ~0;
}
- //discover the usrps
- std::vector<uhd::device_addr_t> device_addrs = uhd::device::discover(device_addr);
for (size_t i = 0; i < device_addrs.size(); i++){
std::cout << "--------------------------------------------------" << std::endl;
std::cout << "-- USRP Device " << i << std::endl;
std::cout << "--------------------------------------------------" << std::endl;
std::cout << device_addrs[i] << std::endl << std::endl;
//make each device just to test (TODO: remove this)
- uhd::device::sptr dev = device::make(device_addrs[i]);
+ uhd::device::sptr dev = uhd::device::make(device_addrs[i]);
std::cout << wax::cast<std::string>((*dev)[uhd::DEVICE_PROP_MBOARD][uhd::MBOARD_PROP_NAME]) << std::endl;
}
diff --git a/host/include/uhd/CMakeLists.txt b/host/include/uhd/CMakeLists.txt
index 006c54f22..f4fb96786 100644
--- a/host/include/uhd/CMakeLists.txt
+++ b/host/include/uhd/CMakeLists.txt
@@ -24,8 +24,8 @@ INSTALL(FILES
device_addr.hpp
dict.hpp
gain_handler.hpp
+ metadata.hpp
props.hpp
- shared_iovec.hpp
time_spec.hpp
utils.hpp
wax.hpp
diff --git a/host/include/uhd/device.hpp b/host/include/uhd/device.hpp
index dfbfbd7c0..ba5337d33 100644
--- a/host/include/uhd/device.hpp
+++ b/host/include/uhd/device.hpp
@@ -20,13 +20,12 @@
#include <uhd/device_addr.hpp>
#include <uhd/props.hpp>
+#include <uhd/metadata.hpp>
#include <uhd/wax.hpp>
#include <boost/utility.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/function.hpp>
#include <boost/asio/buffer.hpp>
-#include <uhd/shared_iovec.hpp>
-#include <vector>
namespace uhd{
@@ -39,10 +38,6 @@ class device : boost::noncopyable, public wax::obj{
public:
typedef boost::shared_ptr<device> sptr;
- //structors
- device(void);
- virtual ~device(void);
-
/*!
* \brief Discover usrp devices attached to the host.
*
@@ -72,9 +67,33 @@ public:
*/
device_addr_t get_device_addr(void);
- //the io interface
- virtual void send_raw(const std::vector<boost::asio::const_buffer> &) = 0;
- virtual uhd::shared_iovec recv_raw(void) = 0;
+ /*!
+ * Send a buffer containing IF data with its metadata.
+ *
+ * \param buff a buffer pointing to some read-only memory
+ * \param metadata data describing the buffer's contents
+ * \param the type of data loaded in the buffer (32fc, 16sc)
+ * \return the number of samples sent
+ */
+ virtual size_t send(
+ const boost::asio::const_buffer &buff,
+ const metadata_t &metadata,
+ const std::string &type = "32fc"
+ ) = 0;
+
+ /*!
+ * Receive a buffer containing IF data and its metadata.
+ *
+ * \param buff the buffer to fill with IF data
+ * \param metadata data to fill describing the buffer
+ * \param the type of data to fill into the buffer (32fc, 16sc)
+ * \return the number of samples received
+ */
+ virtual size_t recv(
+ const boost::asio::mutable_buffer &buff,
+ metadata_t &metadata,
+ const std::string &type = "32fc"
+ ) = 0;
};
} //namespace uhd
diff --git a/host/include/uhd/device_addr.hpp b/host/include/uhd/device_addr.hpp
index 8ea580321..d02febd6c 100644
--- a/host/include/uhd/device_addr.hpp
+++ b/host/include/uhd/device_addr.hpp
@@ -56,7 +56,9 @@ namespace uhd{
* \param device_addr a device address instance
* \return the string representation
*/
- std::string device_addr_to_string(const device_addr_t &device_addr);
+ struct device_addr{
+ static std::string to_string(const device_addr_t &device_addr);
+ };
} //namespace uhd
diff --git a/host/include/uhd/metadata.hpp b/host/include/uhd/metadata.hpp
new file mode 100644
index 000000000..70842e7bc
--- /dev/null
+++ b/host/include/uhd/metadata.hpp
@@ -0,0 +1,51 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program 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 of the License, or
+// (at your option) any later version.
+//
+// This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDED_UHD_METADATA_HPP
+#define INCLUDED_UHD_METADATA_HPP
+
+#include <uhd/time_spec.hpp>
+
+namespace uhd{
+
+/*!
+ * Metadata structure for describing the IF data.
+ * Includes stream ID, time specification, and burst flags.
+ * The receive routines will convert IF data headers into metadata.
+ * The send routines will convert the metadata to IF data headers.
+ */
+struct metadata_t{
+ uint32_t stream_id;
+ bool has_stream_id;
+ time_spec_t time_spec;
+ bool has_time_spec;
+ bool start_of_burst;
+ bool end_of_burst;
+
+ metadata_t(void){
+ stream_id = 0;
+ has_stream_id = false;
+ time_spec = time_spec_t();
+ has_time_spec = false;
+ start_of_burst = false;
+ end_of_burst = false;
+ }
+};
+
+} //namespace uhd
+
+#endif /* INCLUDED_UHD_METADATA_HPP */
diff --git a/host/include/uhd/shared_iovec.hpp b/host/include/uhd/shared_iovec.hpp
deleted file mode 100644
index a120e55d5..000000000
--- a/host/include/uhd/shared_iovec.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//
-// Copyright 2010 Ettus Research LLC
-//
-// This program 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 of the License, or
-// (at your option) any later version.
-//
-// This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
-//
-
-#ifndef INCLUDED_UHD_SHARED_IOVEC_HPP
-#define INCLUDED_UHD_SHARED_IOVEC_HPP
-
-#include <boost/shared_array.hpp>
-#include <stdint.h>
-
-namespace uhd{
-
-/*!
- * A shared iovec contains a shared array and its length.
- * Creating a new shared iovec allocates new memory.
- * This memory is freed when all copies are destroyed.
- */
-class shared_iovec{
-public:
- /*!
- * Create a shared iovec and allocate memory.
- * \param len the length in bytes
- */
- shared_iovec(size_t len=0);
-
- /*!
- * Destroy a shared iovec.
- * Will not free the memory unless this is the last copy.
- */
- ~shared_iovec(void);
-
- void *base;
- size_t len;
-
-private:
- boost::shared_array<uint8_t> _shared_array;
-};
-
-} //namespace uhd
-
-#endif /* INCLUDED_UHD_SHARED_IOVEC_HPP */
diff --git a/host/include/uhd/transport/udp.hpp b/host/include/uhd/transport/udp.hpp
index 6db6bd377..8c6fb096f 100644
--- a/host/include/uhd/transport/udp.hpp
+++ b/host/include/uhd/transport/udp.hpp
@@ -18,7 +18,6 @@
#include <boost/asio.hpp>
#include <boost/utility.hpp>
#include <boost/shared_ptr.hpp>
-#include <uhd/shared_iovec.hpp>
#ifndef INCLUDED_UHD_TRANSPORT_UDP_HPP
#define INCLUDED_UHD_TRANSPORT_UDP_HPP
@@ -30,44 +29,46 @@ public:
typedef boost::shared_ptr<udp> sptr;
/*!
- * Constructor.
+ * Make a new udp transport.
* The address will be resolved, it can be a host name or ipv4.
* The port will be resolved, it can be a port type or number.
* \param addr a string representing the destination address
* \param port a string representing the destination port
* \param bcast if true, enable the broadcast option on the socket
*/
- udp(const std::string &addr, const std::string &port, bool bcast = false);
-
- /*!
- * Destructor
- */
- ~udp(void);
+ static sptr make(const std::string &addr, const std::string &port, bool bcast = false);
/*!
* Send a vector of buffer (like send_msg).
+ * Blocks until the data is sent.
* \param buffs a vector of asio buffers
+ * \return the number of bytes sent
*/
- void send(const std::vector<boost::asio::const_buffer> &buffs);
+ virtual size_t send(const std::vector<boost::asio::const_buffer> &buffs) = 0;
/*!
* Send a single buffer.
+ * Blocks until the data is sent.
* \param buff single asio buffer
+ * \return the number of bytes sent
*/
- void send(const boost::asio::const_buffer &buff);
+ virtual size_t send(const boost::asio::const_buffer &buff) = 0;
/*!
- * Receive a buffer. The memory is managed internally.
- * Calling recv will invalidate the buffer of the previous recv.
- * \return a shared iovec with allocated memory
+ * Receive a buffer. Write into the memory provided.
+ * Returns empty when data is not available.
+ * \param buffs a vector of asio buffers
+ * \return the number of bytes received.
*/
- uhd::shared_iovec recv(void);
+ virtual size_t recv(const std::vector<boost::asio::mutable_buffer> &buffs) = 0;
-private:
- boost::asio::ip::udp::socket *_socket;
- boost::asio::ip::udp::endpoint _receiver_endpoint;
- boost::asio::ip::udp::endpoint _sender_endpoint;
- boost::asio::io_service _io_service;
+ /*!
+ * Receive a buffer. Write into the memory provided.
+ * Returns empty when data is not available.
+ * \param buff a mutable buffer to receive into
+ * \return the number of bytes received.
+ */
+ virtual size_t recv(const boost::asio::mutable_buffer &buff) = 0;
};
}} //namespace
diff --git a/host/include/uhd/usrp/CMakeLists.txt b/host/include/uhd/usrp/CMakeLists.txt
index e7bdc1784..4e0a92365 100644
--- a/host/include/uhd/usrp/CMakeLists.txt
+++ b/host/include/uhd/usrp/CMakeLists.txt
@@ -21,6 +21,7 @@ INSTALL(FILES
dboard_id.hpp
dboard_interface.hpp
dboard_manager.hpp
+ usrp1e.hpp
usrp2.hpp
DESTINATION ${HEADER_DIR}/uhd/usrp
)
diff --git a/host/include/uhd/usrp/usrp1e.hpp b/host/include/uhd/usrp/usrp1e.hpp
new file mode 100644
index 000000000..00748e55f
--- /dev/null
+++ b/host/include/uhd/usrp/usrp1e.hpp
@@ -0,0 +1,48 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program 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 of the License, or
+// (at your option) any later version.
+//
+// This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDED_UHD_USRP_USRP1E_HPP
+#define INCLUDED_UHD_USRP_USRP1E_HPP
+
+#include <uhd/device.hpp>
+
+namespace uhd{ namespace usrp{
+
+/*!
+ * The usrp1e device class.
+ */
+class usrp1e : public device{
+public:
+ /*!
+ * Discover usrp1e devices on the system via the device node.
+ * This static method will be called by the device::discover.
+ * \param hint a device addr with the usrp1e address filled in
+ * \return a vector of device addresses for all usrp1es found
+ */
+ static device_addrs_t discover(const device_addr_t &hint);
+
+ /*!
+ * Make a usrp1e from a device address.
+ * \param addr the device address
+ * \return a device sptr to a new usrp1e
+ */
+ static device::sptr make(const device_addr_t &addr);
+};
+
+}} //namespace
+
+#endif /* INCLUDED_UHD_USRP_USRP1E_HPP */
diff --git a/host/include/uhd/usrp/usrp2.hpp b/host/include/uhd/usrp/usrp2.hpp
index f6e49cbd6..da7ec595a 100644
--- a/host/include/uhd/usrp/usrp2.hpp
+++ b/host/include/uhd/usrp/usrp2.hpp
@@ -15,8 +15,8 @@
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
-#ifndef INCLUDED_UHD_USRP_MBOARD_USRP2_HPP
-#define INCLUDED_UHD_USRP_MBOARD_USRP2_HPP
+#ifndef INCLUDED_UHD_USRP_USRP2_HPP
+#define INCLUDED_UHD_USRP_USRP2_HPP
#include <uhd/device.hpp>
@@ -45,4 +45,4 @@ public:
}} //namespace
-#endif /* INCLUDED_UHD_USRP_MBOARD_USRP2_HPP */
+#endif /* INCLUDED_UHD_USRP_USRP2_HPP */
diff --git a/host/lib/CMakeLists.txt b/host/lib/CMakeLists.txt
index 5cf334678..edfefa127 100644
--- a/host/lib/CMakeLists.txt
+++ b/host/lib/CMakeLists.txt
@@ -15,12 +15,13 @@
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
-
+########################################################################
+# Create a list of libuhd sources
+########################################################################
SET(libuhd_sources
device.cpp
device_addr.cpp
gain_handler.cpp
- shared_iovec.cpp
uhd.cpp
wax.cpp
transport/udp.cpp
@@ -32,10 +33,21 @@ SET(libuhd_sources
usrp/usrp2/dboard_impl.cpp
usrp/usrp2/dboard_interface.cpp
usrp/usrp2/dsp_impl.cpp
+ usrp/usrp2/io_impl.cpp
usrp/usrp2/mboard_impl.cpp
usrp/usrp2/usrp2_impl.cpp
)
+########################################################################
+# Conditionally add the usrp1e sources
+########################################################################
+LIST(APPEND libuhd_sources
+ usrp/usrp1e/usrp1e_none.cpp
+)
+
+########################################################################
+# Setup libuhd library
+########################################################################
ADD_LIBRARY(uhd SHARED ${libuhd_sources})
TARGET_LINK_LIBRARIES(uhd ${Boost_LIBRARIES})
diff --git a/host/lib/device.cpp b/host/lib/device.cpp
index e376a5c50..82052708a 100644
--- a/host/lib/device.cpp
+++ b/host/lib/device.cpp
@@ -12,57 +12,122 @@
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
-// along with this program. If not, see <http://www.gnu.org/licenses/>.
+// asize_t with this program. If not, see <http://www.gnu.org/licenses/>.
//
+#include <uhd/usrp/usrp1e.hpp>
#include <uhd/usrp/usrp2.hpp>
-#include <uhd/device.hpp>
+#include <uhd/dict.hpp>
+#include <uhd/utils.hpp>
+#include <boost/foreach.hpp>
#include <boost/format.hpp>
+#include <boost/weak_ptr.hpp>
+#include <boost/functional/hash.hpp>
#include <stdexcept>
+#include <algorithm>
using namespace uhd;
+/*!
+ * Create a new device from a device address.
+ * Based on the address, call the appropriate make functions.
+ * \param dev_addr the device address
+ * \return a smart pointer to a device
+ */
+static device::sptr make_device(const device_addr_t &dev_addr){
+
+ //create a usrp1e
+ if (dev_addr["type"] == "usrp1e"){
+ return usrp::usrp1e::make(dev_addr);
+ }
+
+ //create a usrp2
+ if (dev_addr["type"] == "usrp2"){
+ return usrp::usrp2::make(dev_addr);
+ }
+
+ throw std::runtime_error("cant make a device");
+}
+
+/*!
+ * Make a device hash that maps 1 to 1 with a device address.
+ * The hash will be used to identify created devices.
+ * \param dev_addr the device address
+ * \return the hash number
+ */
+static size_t hash_device_addr(
+ const device_addr_t &dev_addr
+){
+ //sort the keys of the device address
+ std::vector<std::string> keys = dev_addr.get_keys();
+ std::sort(keys.begin(), keys.end());
+
+ //combine the hashes of sorted keys/value pairs
+ size_t hash = 0;
+ BOOST_FOREACH(std::string key, keys){
+ boost::hash_combine(hash, key);
+ boost::hash_combine(hash, dev_addr[key]);
+ }
+ return hash;
+}
+
+/***********************************************************************
+ * Discover
+ **********************************************************************/
device_addrs_t device::discover(const device_addr_t &hint){
device_addrs_t device_addrs;
- if (not hint.has_key("type")){
- //TODO call discover for others and append results
- }
- else if (hint["type"] == "udp"){
+
+ //discover the usrp1es
+ std::vector<device_addr_t> usrp2_addrs = usrp::usrp1e::discover(hint);
+ device_addrs.insert(device_addrs.begin(), usrp2_addrs.begin(), usrp2_addrs.end());
+
+ //discover the usrp2s
+ if (hint.has_key("addr")){
std::vector<device_addr_t> usrp2_addrs = usrp::usrp2::discover(hint);
device_addrs.insert(device_addrs.begin(), usrp2_addrs.begin(), usrp2_addrs.end());
}
+
return device_addrs;
}
+/***********************************************************************
+ * Make
+ **********************************************************************/
device::sptr device::make(const device_addr_t &hint, size_t which){
std::vector<device_addr_t> device_addrs = discover(hint);
//check that we found any devices
if (device_addrs.size() == 0){
throw std::runtime_error(str(
- boost::format("No devices found for %s") % device_addr_to_string(hint)
+ boost::format("No devices found for %s") % device_addr::to_string(hint)
));
}
//check that the which index is valid
if (device_addrs.size() <= which){
throw std::runtime_error(str(
- boost::format("No device at index %d for %s") % which % device_addr_to_string(hint)
+ boost::format("No device at index %d for %s") % which % device_addr::to_string(hint)
));
}
- //create the new device with the discovered address
- //TODO only a usrp2 device will be made (until others are supported)
- if (hint.has_key("type") and hint["type"] == "udp"){
- return usrp::usrp2::make(device_addrs.at(which));
- }
- throw std::runtime_error("cant make a device");
-}
+ //create a unique hash for the device address
+ device_addr_t dev_addr = device_addrs.at(which);
+ size_t dev_hash = hash_device_addr(dev_addr);
+ //std::cout << boost::format("Hash: %u") % dev_hash << std::endl;
-device::device(void){
- /* NOP */
-}
+ //map device address hash to created devices
+ static uhd::dict<size_t, boost::weak_ptr<device> > hash_to_device;
-device::~device(void){
- /* NOP */
+ //try to find an existing device
+ try{
+ ASSERT_THROW(hash_to_device.has_key(dev_hash));
+ ASSERT_THROW(not hash_to_device[dev_hash].expired());
+ return hash_to_device[dev_hash].lock();
+ }
+ //create and register a new device
+ catch(const std::assert_error &e){
+ device::sptr dev = make_device(dev_addr);
+ hash_to_device[dev_hash] = dev;
+ return dev;
+ }
}
diff --git a/host/lib/device_addr.cpp b/host/lib/device_addr.cpp
index ffd511f92..9514df981 100644
--- a/host/lib/device_addr.cpp
+++ b/host/lib/device_addr.cpp
@@ -72,7 +72,7 @@ std::ostream& operator<<(std::ostream &os, const uhd::mac_addr_t &x){
}
//----------------------- usrp device_addr_t wrapper -------------------------//
-std::string uhd::device_addr_to_string(const uhd::device_addr_t &device_addr){
+std::string uhd::device_addr::to_string(const uhd::device_addr_t &device_addr){
std::stringstream ss;
BOOST_FOREACH(std::string key, device_addr.get_keys()){
ss << boost::format("%s: %s") % key % device_addr[key] << std::endl;
@@ -81,6 +81,6 @@ std::string uhd::device_addr_to_string(const uhd::device_addr_t &device_addr){
}
std::ostream& operator<<(std::ostream &os, const uhd::device_addr_t &device_addr){
- os << uhd::device_addr_to_string(device_addr);
+ os << uhd::device_addr::to_string(device_addr);
return os;
}
diff --git a/host/lib/transport/udp.cpp b/host/lib/transport/udp.cpp
index 06defb107..878f71410 100644
--- a/host/lib/transport/udp.cpp
+++ b/host/lib/transport/udp.cpp
@@ -17,10 +17,45 @@
#include <uhd/transport/udp.hpp>
#include <boost/format.hpp>
-#include <boost/assign/list_of.hpp>
#include <iostream>
-uhd::transport::udp::udp(const std::string &addr, const std::string &port, bool bcast){
+/***********************************************************************
+ * UDP implementation class
+ **********************************************************************/
+class udp_impl : public uhd::transport::udp{
+public:
+ //structors
+ udp_impl(const std::string &addr, const std::string &port, bool bcast);
+ ~udp_impl(void);
+
+ //send/recv
+ size_t send(const std::vector<boost::asio::const_buffer> &buffs);
+ size_t send(const boost::asio::const_buffer &buff);
+ size_t recv(const std::vector<boost::asio::mutable_buffer> &buffs);
+ size_t recv(const boost::asio::mutable_buffer &buff);
+
+private:
+ boost::asio::ip::udp::socket *_socket;
+ boost::asio::ip::udp::endpoint _receiver_endpoint;
+ boost::asio::ip::udp::endpoint _sender_endpoint;
+ boost::asio::io_service _io_service;
+};
+
+/***********************************************************************
+ * UDP public make function
+ **********************************************************************/
+uhd::transport::udp::sptr uhd::transport::udp::make(
+ const std::string &addr,
+ const std::string &port,
+ bool bcast
+){
+ return uhd::transport::udp::sptr(new udp_impl(addr, port, bcast));
+}
+
+/***********************************************************************
+ * UDP implementation methods
+ **********************************************************************/
+udp_impl::udp_impl(const std::string &addr, const std::string &port, bool bcast){
//std::cout << boost::format("Creating udp transport for %s %s") % addr % port << std::endl;
// resolve the address
@@ -40,28 +75,24 @@ uhd::transport::udp::udp(const std::string &addr, const std::string &port, bool
}
-uhd::transport::udp::~udp(void){
+udp_impl::~udp_impl(void){
delete _socket;
}
-void uhd::transport::udp::send(const std::vector<boost::asio::const_buffer> &buffs){
- _socket->send_to(buffs, _receiver_endpoint);
+size_t udp_impl::send(const std::vector<boost::asio::const_buffer> &buffs){
+ return _socket->send_to(buffs, _receiver_endpoint);
}
-void uhd::transport::udp::send(const boost::asio::const_buffer &buff){
- std::vector<boost::asio::const_buffer> buffs = boost::assign::list_of(buff);
- send(buffs);
+size_t udp_impl::send(const boost::asio::const_buffer &buff){
+ return _socket->send_to(boost::asio::buffer(buff), _receiver_endpoint);
}
-uhd::shared_iovec uhd::transport::udp::recv(void){
- //allocate a buffer for the number of bytes available (could be zero)
- uhd::shared_iovec iov(_socket->available());
- //call recv only if data is available
- if (iov.len != 0){
- _socket->receive_from(
- boost::asio::buffer(iov.base, iov.len),
- _sender_endpoint
- );
- }
- return iov;
+size_t udp_impl::recv(const std::vector<boost::asio::mutable_buffer> &buffs){
+ if (_socket->available() == 0) return 0;
+ return _socket->receive_from(buffs, _sender_endpoint);
+}
+
+size_t udp_impl::recv(const boost::asio::mutable_buffer &buff){
+ if (_socket->available() == 0) return 0;
+ return _socket->receive_from(boost::asio::buffer(buff), _sender_endpoint);
}
diff --git a/host/lib/usrp/dboard_manager.cpp b/host/lib/usrp/dboard_manager.cpp
index f0846db25..cce239f3e 100644
--- a/host/lib/usrp/dboard_manager.cpp
+++ b/host/lib/usrp/dboard_manager.cpp
@@ -91,6 +91,8 @@ private:
//the subdevice proxy is internal to the cpp file
uhd::dict<std::string, wax::obj> _rx_dboards;
uhd::dict<std::string, wax::obj> _tx_dboards;
+ dboard_interface::sptr _interface;
+ void set_nice_gpio_pins(void);
};
/***********************************************************************
@@ -184,6 +186,7 @@ dboard_manager_impl::dboard_manager_impl(
dboard_interface::sptr interface
){
register_internal_dboards(); //always call first
+ _interface = interface;
dboard_ctor_t rx_dboard_ctor; prop_names_t rx_subdevs;
boost::tie(rx_dboard_ctor, rx_subdevs) = get_dboard_args(rx_dboard_id, "rx");
@@ -192,14 +195,7 @@ dboard_manager_impl::dboard_manager_impl(
boost::tie(tx_dboard_ctor, tx_subdevs) = get_dboard_args(tx_dboard_id, "tx");
//initialize the gpio pins before creating subdevs
- interface->set_gpio_ddr(dboard_interface::GPIO_RX_BANK, 0x0000, 0xffff); //all inputs
- interface->set_gpio_ddr(dboard_interface::GPIO_TX_BANK, 0x0000, 0xffff);
-
- interface->write_gpio(dboard_interface::GPIO_RX_BANK, 0x0000, 0xffff); //all zeros
- interface->write_gpio(dboard_interface::GPIO_TX_BANK, 0x0000, 0xffff);
-
- interface->set_atr_reg(dboard_interface::GPIO_RX_BANK, 0x0000, 0x0000, 0x0000); //software controlled
- interface->set_atr_reg(dboard_interface::GPIO_TX_BANK, 0x0000, 0x0000, 0x0000);
+ set_nice_gpio_pins();
//make xcvr subdevs (make one subdev for both rx and tx dboards)
if (rx_dboard_ctor == tx_dboard_ctor){
@@ -245,7 +241,7 @@ dboard_manager_impl::dboard_manager_impl(
}
dboard_manager_impl::~dboard_manager_impl(void){
- /* NOP */
+ set_nice_gpio_pins();
}
prop_names_t dboard_manager_impl::get_rx_subdev_names(void){
@@ -271,3 +267,16 @@ wax::obj dboard_manager_impl::get_tx_subdev(const std::string &subdev_name){
//get a link to the tx subdev proxy
return wax::cast<subdev_proxy::sptr>(_tx_dboards[subdev_name])->get_link();
}
+
+void dboard_manager_impl::set_nice_gpio_pins(void){
+ //std::cout << "Set nice GPIO pins" << std::endl;
+
+ _interface->set_gpio_ddr(dboard_interface::GPIO_RX_BANK, 0x0000, 0xffff); //all inputs
+ _interface->set_gpio_ddr(dboard_interface::GPIO_TX_BANK, 0x0000, 0xffff);
+
+ _interface->write_gpio(dboard_interface::GPIO_RX_BANK, 0x0000, 0xffff); //all zeros
+ _interface->write_gpio(dboard_interface::GPIO_TX_BANK, 0x0000, 0xffff);
+
+ _interface->set_atr_reg(dboard_interface::GPIO_RX_BANK, 0x0000, 0x0000, 0x0000); //software controlled
+ _interface->set_atr_reg(dboard_interface::GPIO_TX_BANK, 0x0000, 0x0000, 0x0000);
+}
diff --git a/host/lib/shared_iovec.cpp b/host/lib/usrp/usrp1e/usrp1e_none.cpp
index 60062fbf0..1c8cf9a5b 100644
--- a/host/lib/shared_iovec.cpp
+++ b/host/lib/usrp/usrp1e/usrp1e_none.cpp
@@ -15,14 +15,20 @@
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
-#include <uhd/shared_iovec.hpp>
+#include <uhd/usrp/usrp1e.hpp>
-uhd::shared_iovec::shared_iovec(size_t len_){
- _shared_array = boost::shared_array<uint8_t>(new uint8_t[len_]);
- base = _shared_array.get();
- len = len_;
+using namespace uhd;
+using namespace uhd::usrp;
+
+/*!
+ * This file defines the usrp1e discover and make functions
+ * when the required kernel module headers are not present.
+ */
+
+device_addrs_t usrp1e::discover(const device_addr_t &){
+ return device_addrs_t(); //return empty list
}
-uhd::shared_iovec::~shared_iovec(void){
- /* NOP */
+device::sptr usrp1e::make(const device_addr_t &){
+ throw std::runtime_error("this build has no usrp1e support");
}
diff --git a/host/lib/usrp/usrp2/io_impl.cpp b/host/lib/usrp/usrp2/io_impl.cpp
new file mode 100644
index 000000000..43334ddc6
--- /dev/null
+++ b/host/lib/usrp/usrp2/io_impl.cpp
@@ -0,0 +1,242 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program 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 of the License, or
+// (at your option) any later version.
+//
+// This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <complex>
+#include <boost/shared_array.hpp>
+#include <boost/format.hpp>
+#include "usrp2_impl.hpp"
+
+using namespace uhd;
+using namespace uhd::usrp;
+
+/***********************************************************************
+ * Constants
+ **********************************************************************/
+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;
+
+/***********************************************************************
+ * 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));
+ }
+}
+
+static inline void usrp2_shorts_to_host_floats(
+ float *host_floats,
+ const int16_t *usrp2_shorts,
+ size_t num_samps
+){
+ for(size_t i = 0; i < num_samps; i++){
+ host_floats[i] = float(ntohs(usrp2_shorts[i])/float_scale_factor);
+ }
+}
+
+static inline void host_shorts_to_usrp2_shorts(
+ int16_t *usrp2_shorts,
+ const int16_t *host_shorts,
+ size_t num_samps
+){
+ for(size_t i = 0; i < num_samps; i++){
+ usrp2_shorts[i] = htons(host_shorts[i]);
+ }
+}
+
+static inline void usrp2_shorts_to_host_shorts(
+ int16_t *host_shorts,
+ const int16_t *usrp2_shorts,
+ size_t num_samps
+){
+ for(size_t i = 0; i < num_samps; i++){
+ host_shorts[i] = ntohs(usrp2_shorts[i]);
+ }
+}
+
+/***********************************************************************
+ * Send Raw Data
+ **********************************************************************/
+size_t usrp2_impl::send_raw(
+ const boost::asio::const_buffer &buff,
+ const uhd::metadata_t &metadata
+){
+ 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(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
+ }
+ 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;
+
+ //receive into the buffers
+ size_t bytes_recvd = _data_transport->recv(buffs);
+
+ //failure case
+ if (bytes_recvd < max_vrt_header_words*sizeof(uint32_t)) return 0;
+
+ //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);
+}
+
+/***********************************************************************
+ * Send Data
+ **********************************************************************/
+size_t usrp2_impl::send(
+ const boost::asio::const_buffer &buff,
+ const uhd::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);
+ }
+
+ 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
+ );
+
+ return send_raw(raw_buff, metadata);
+ #endif
+ }
+
+ throw std::runtime_error(str(boost::format("usrp2 send: cannot handle type \"%s\"") % type));
+}
+
+/***********************************************************************
+ * Receive Data
+ **********************************************************************/
+size_t usrp2_impl::recv(
+ const boost::asio::mutable_buffer &buff,
+ uhd::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;
+ }
+
+ 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
+ }
+
+ throw std::runtime_error(str(boost::format("usrp2 recv: cannot handle type \"%s\"") % type));
+}
diff --git a/host/lib/usrp/usrp2/usrp2_impl.cpp b/host/lib/usrp/usrp2/usrp2_impl.cpp
index 2b4e8fe39..06876d241 100644
--- a/host/lib/usrp/usrp2/usrp2_impl.cpp
+++ b/host/lib/usrp/usrp2/usrp2_impl.cpp
@@ -33,32 +33,36 @@ uhd::device_addrs_t usrp2::discover(const device_addr_t &hint){
//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);
- uhd::transport::udp udp_transport(hint["addr"], ctrl_port, true);
+ transport::udp::sptr udp_transport = \
+ transport::udp::make(hint["addr"], ctrl_port, true);
//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)));
+ 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;
while(true){
- uhd::shared_iovec iov = udp_transport.recv();
- //std::cout << boost::asio::buffer_size(buff) << "\n";
- if (iov.len < sizeof(usrp2_ctrl_data_t)){
+ usrp2_ctrl_data_t ctrl_data_in;
+ size_t len = udp_transport->recv(
+ boost::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{
//handle the received data
- const usrp2_ctrl_data_t *ctrl_data_in = reinterpret_cast<const usrp2_ctrl_data_t *>(iov.base);
- switch(ntohl(ctrl_data_in->id)){
+ switch(ntohl(ctrl_data_in.id)){
case USRP2_CTRL_ID_THIS_IS_MY_IP_ADDR_DUDE:
//make a boost asio ipv4 with the raw addr in host byte order
- boost::asio::ip::address_v4 ip_addr(ntohl(ctrl_data_in->data.ip_addr));
+ 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"] = "udp";
+ new_addr["type"] = "usrp2";
+ new_addr["transport"] = "udp";
new_addr["addr"] = ip_addr.to_string();
usrp2_addrs.push_back(new_addr);
break;
@@ -72,21 +76,17 @@ uhd::device_addrs_t usrp2::discover(const device_addr_t &hint){
/***********************************************************************
* Make
**********************************************************************/
+#define num2str(num) (boost::lexical_cast<std::string>(num))
+
device::sptr usrp2::make(const device_addr_t &device_addr){
//create a control transport
- uhd::transport::udp::sptr ctrl_transport(
- new uhd::transport::udp(
- device_addr["addr"],
- boost::lexical_cast<std::string>(USRP2_UDP_CTRL_PORT)
- )
+ transport::udp::sptr ctrl_transport = transport::udp::make(
+ device_addr["addr"], num2str(USRP2_UDP_CTRL_PORT)
);
//create a data transport
- uhd::transport::udp::sptr data_transport(
- new uhd::transport::udp(
- device_addr["addr"],
- boost::lexical_cast<std::string>(USRP2_UDP_DATA_PORT)
- )
+ transport::udp::sptr data_transport = transport::udp::make(
+ device_addr["addr"], num2str(USRP2_UDP_DATA_PORT)
);
//create the usrp2 implementation guts
@@ -99,8 +99,8 @@ device::sptr usrp2::make(const device_addr_t &device_addr){
* Structors
**********************************************************************/
usrp2_impl::usrp2_impl(
- uhd::transport::udp::sptr ctrl_transport,
- uhd::transport::udp::sptr data_transport
+ transport::udp::sptr ctrl_transport,
+ transport::udp::sptr data_transport
){
_ctrl_transport = ctrl_transport;
_data_transport = data_transport;
@@ -121,9 +121,6 @@ usrp2_impl::usrp2_impl(
//init the mboard
mboard_init();
- //init the tx and rx dboards
- dboard_init();
-
//init the ddc
init_ddc_config();
@@ -132,6 +129,14 @@ usrp2_impl::usrp2_impl(
//initialize the clock configuration
init_clock_config();
+
+ //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)));
+
}
usrp2_impl::~usrp2_impl(void){
@@ -159,14 +164,16 @@ usrp2_ctrl_data_t usrp2_impl::ctrl_send_and_recv(const usrp2_ctrl_data_t &out_da
//loop and recieve until the time is up
size_t num_timeouts = 0;
while(true){
- uhd::shared_iovec iov = _ctrl_transport->recv();
- if (iov.len < sizeof(usrp2_ctrl_data_t)){
+ 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
- usrp2_ctrl_data_t in_data = *reinterpret_cast<const usrp2_ctrl_data_t *>(iov.base);
if (ntohl(in_data.seq) == _ctrl_seq_num){
return in_data;
}
@@ -202,14 +209,3 @@ void usrp2_impl::get(const wax::obj &key_, wax::obj &val){
void usrp2_impl::set(const wax::obj &, const wax::obj &){
throw std::runtime_error("Cannot set in usrp2 device");
}
-
-/***********************************************************************
- * IO Interface
- **********************************************************************/
-void usrp2_impl::send_raw(const std::vector<boost::asio::const_buffer> &){
- return;
-}
-
-uhd::shared_iovec usrp2_impl::recv_raw(void){
- throw std::runtime_error("not implemented");
-}
diff --git a/host/lib/usrp/usrp2/usrp2_impl.hpp b/host/lib/usrp/usrp2/usrp2_impl.hpp
index 2545efd58..9a4c42d42 100644
--- a/host/lib/usrp/usrp2/usrp2_impl.hpp
+++ b/host/lib/usrp/usrp2/usrp2_impl.hpp
@@ -98,10 +98,15 @@ public:
double get_master_clock_freq(void);
//the io interface
- void send_raw(const std::vector<boost::asio::const_buffer> &);
- uhd::shared_iovec recv_raw(void);
+ 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 &);
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;
+
//udp transports for control and data
uhd::transport::udp::sptr _ctrl_transport;
uhd::transport::udp::sptr _data_transport;
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-28 09:23:03 +0000