summaryrefslogtreecommitdiffstats
path: root/host/lib/usrp
diff options
context:
space:
mode:
Diffstat (limited to 'host/lib/usrp')
-rw-r--r--host/lib/usrp/dboard_manager.cpp27
-rw-r--r--host/lib/usrp/usrp1e/fpga-downloader.cc262
-rw-r--r--host/lib/usrp/usrp1e/usrp1e_impl.cpp69
-rw-r--r--host/lib/usrp/usrp1e/usrp1e_impl.hpp23
-rw-r--r--host/lib/usrp/usrp1e/usrp1e_none.cpp38
-rw-r--r--host/lib/usrp/usrp2/io_impl.cpp242
-rw-r--r--host/lib/usrp/usrp2/usrp2_impl.cpp71
-rw-r--r--host/lib/usrp/usrp2/usrp2_impl.hpp9
8 files changed, 692 insertions, 49 deletions
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/usrp/usrp1e/fpga-downloader.cc b/host/lib/usrp/usrp1e/fpga-downloader.cc
new file mode 100644
index 000000000..f7c78b875
--- /dev/null
+++ b/host/lib/usrp/usrp1e/fpga-downloader.cc
@@ -0,0 +1,262 @@
+//
+// 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 <iostream>
+#include <sstream>
+#include <fstream>
+#include <string>
+#include <cstdlib>
+
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+
+#include <linux/spi/spidev.h>
+
+/*
+ * Configuration connections
+ *
+ * CCK - MCSPI1_CLK
+ * DIN - MCSPI1_MOSI
+ * PROG_B - GPIO_175 - output (change mux)
+ * DONE - GPIO_173 - input (change mux)
+ * INIT_B - GPIO_114 - input (change mux)
+ *
+*/
+
+const unsigned int PROG_B = 175;
+const unsigned int DONE = 173;
+const unsigned int INIT_B = 114;
+
+//static std::string bit_file = "safe_u1e.bin";
+
+const int BUF_SIZE = 4096;
+
+enum gpio_direction {IN, OUT};
+
+class gpio {
+ public:
+
+ gpio(unsigned int gpio_num, gpio_direction pin_direction);
+
+ bool get_value();
+ void set_value(bool state);
+
+ private:
+
+ std::stringstream base_path;
+ std::fstream value_file;
+};
+
+class spidev {
+ public:
+
+ spidev(std::string dev_name);
+ ~spidev();
+
+ void send(char *wbuf, char *rbuf, unsigned int nbytes);
+
+ private:
+
+ int fd;
+
+};
+
+gpio::gpio(unsigned int gpio_num, gpio_direction pin_direction)
+{
+ std::fstream export_file;
+
+ export_file.open("/sys/class/gpio/export", std::ios::out);
+ if (!export_file.is_open()) ///\todo Poor error handling
+ std::cout << "Failed to open gpio export file." << std::endl;
+
+ export_file << gpio_num << std::endl;
+
+ base_path << "/sys/class/gpio/gpio" << gpio_num << std::flush;
+
+ std::fstream direction_file;
+ std::string direction_file_name;
+
+ direction_file_name = base_path.str() + "/direction";
+
+ direction_file.open(direction_file_name.c_str());
+ if (!direction_file.is_open())
+ std::cout << "Failed to open direction file." << std::endl;
+ if (pin_direction == OUT)
+ direction_file << "out" << std::endl;
+ else
+ direction_file << "in" << std::endl;
+
+ std::string value_file_name;
+
+ value_file_name = base_path.str() + "/value";
+
+ value_file.open(value_file_name.c_str(), std::ios_base::in | std::ios_base::out);
+ if (!value_file.is_open())
+ std::cout << "Failed to open value file." << std::endl;
+}
+
+bool gpio::get_value()
+{
+
+ std::string val;
+
+ std::getline(value_file, val);
+ value_file.seekg(0);
+
+ if (val == "0")
+ return false;
+ else if (val == "1")
+ return true;
+ else
+ std::cout << "Data read from value file|" << val << "|" << std::endl;
+
+ return false;
+}
+
+void gpio::set_value(bool state)
+{
+
+ if (state)
+ value_file << "1" << std::endl;
+ else
+ value_file << "0" << std::endl;
+}
+
+static void prepare_fpga_for_configuration(gpio &prog, gpio &)//init)
+{
+
+ prog.set_value(true);
+ prog.set_value(false);
+ prog.set_value(true);
+
+#if 0
+ bool ready_to_program(false);
+ unsigned int count(0);
+ do {
+ ready_to_program = init.get_value();
+ count++;
+
+ sleep(1);
+ } while (count < 10 && !ready_to_program);
+
+ if (count == 10) {
+ std::cout << "FPGA not ready for programming." << std::endl;
+ exit(-1);
+ }
+#endif
+}
+
+spidev::spidev(std::string fname)
+{
+ int ret;
+ int mode = 0;
+ int speed = 12000000;
+ int bits = 8;
+
+ fd = open(fname.c_str(), O_RDWR);
+
+ ret = ioctl(fd, SPI_IOC_WR_MODE, &mode);
+ ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
+ ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);
+}
+
+
+spidev::~spidev()
+{
+ close(fd);
+}
+
+void spidev::send(char *buf, char *rbuf, unsigned int nbytes)
+{
+ int ret;
+
+ struct spi_ioc_transfer tr;
+ tr.tx_buf = (unsigned long) buf;
+ tr.rx_buf = (unsigned long) rbuf;
+ tr.len = nbytes;
+ tr.delay_usecs = 0;
+ tr.speed_hz = 48000000;
+ tr.bits_per_word = 8;
+
+ ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
+
+}
+
+static void send_file_to_fpga(const std::string &file_name, gpio &error, gpio &done)
+{
+ std::ifstream bitstream;
+
+ std::cout << "File name - " << file_name.c_str() << std::endl;
+
+ bitstream.open(file_name.c_str(), std::ios::binary);
+ if (!bitstream.is_open())
+ std::cout << "File " << file_name << " not opened succesfully." << std::endl;
+
+ spidev spi("/dev/spidev1.0");
+ char buf[BUF_SIZE];
+ char rbuf[BUF_SIZE];
+
+ do {
+ bitstream.read(buf, BUF_SIZE);
+ spi.send(buf, rbuf, bitstream.gcount());
+
+ if (error.get_value())
+ std::cout << "INIT_B went high, error occured." << std::endl;
+
+ if (!done.get_value())
+ std::cout << "Configuration complete." << std::endl;
+
+ } while (bitstream.gcount() == BUF_SIZE);
+}
+
+/*
+int main(int argc, char *argv[])
+{
+
+ gpio gpio_prog_b(PROG_B, OUT);
+ gpio gpio_init_b(INIT_B, IN);
+ gpio gpio_done (DONE, IN);
+
+ if (argc == 2)
+ bit_file = argv[1];
+
+ std::cout << "FPGA config file: " << bit_file << std::endl;
+
+ prepare_fpga_for_configuration(gpio_prog_b, gpio_init_b);
+
+ std::cout << "Done = " << gpio_done.get_value() << std::endl;
+
+ send_file_to_fpga(bit_file, gpio_init_b, gpio_done);
+}
+*/
+
+#include <uhd/usrp/usrp1e.hpp>
+void uhd::usrp::usrp1e::load_fpga(const std::string &bin_file){
+ gpio gpio_prog_b(PROG_B, OUT);
+ gpio gpio_init_b(INIT_B, IN);
+ gpio gpio_done (DONE, IN);
+
+ std::cout << "FPGA config file: " << bin_file << std::endl;
+
+ prepare_fpga_for_configuration(gpio_prog_b, gpio_init_b);
+
+ std::cout << "Done = " << gpio_done.get_value() << std::endl;
+
+ send_file_to_fpga(bin_file, gpio_init_b, gpio_done);
+}
diff --git a/host/lib/usrp/usrp1e/usrp1e_impl.cpp b/host/lib/usrp/usrp1e/usrp1e_impl.cpp
new file mode 100644
index 000000000..93265ab17
--- /dev/null
+++ b/host/lib/usrp/usrp1e/usrp1e_impl.cpp
@@ -0,0 +1,69 @@
+//
+// 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 <unistd.h>
+#include <boost/format.hpp>
+#include "usrp1e_impl.hpp"
+
+using namespace uhd;
+using namespace uhd::usrp;
+
+/***********************************************************************
+ * Helper Functions
+ **********************************************************************/
+static bool file_exists(const std::string &file_path){
+ return access(file_path.c_str(), F_OK) == 0;
+}
+
+/***********************************************************************
+ * Discovery
+ **********************************************************************/
+device_addrs_t usrp1e::discover(const device_addr_t &device_addr){
+ device_addrs_t usrp1e_addrs;
+
+ //if a node was provided, use it and only it
+ if (device_addr.has_key("node")){
+ if (not file_exists(device_addr["node"])) return usrp1e_addrs;
+ device_addr_t new_addr;
+ new_addr["name"] = "USRP1E";
+ new_addr["type"] = "usrp1e";
+ new_addr["node"] = device_addr["node"];
+ usrp1e_addrs.push_back(new_addr);
+ }
+
+ //otherwise look for a few nodes at small indexes
+ else{
+ for(size_t i = 0; i < 5; i++){
+ std::string node = str(boost::format("/dev/usrp1_e%d") % i);
+ if (not file_exists(node)) continue;
+ device_addr_t new_addr;
+ new_addr["name"] = "USRP1E";
+ new_addr["type"] = "usrp1e";
+ new_addr["node"] = node;
+ usrp1e_addrs.push_back(new_addr);
+ }
+ }
+
+ return usrp1e_addrs;
+}
+
+/***********************************************************************
+ * Make
+ **********************************************************************/
+device::sptr usrp1e::make(const device_addr_t &){
+ throw std::runtime_error("not implemented yet");
+}
diff --git a/host/lib/usrp/usrp1e/usrp1e_impl.hpp b/host/lib/usrp/usrp1e/usrp1e_impl.hpp
new file mode 100644
index 000000000..3f5f89ec6
--- /dev/null
+++ b/host/lib/usrp/usrp1e/usrp1e_impl.hpp
@@ -0,0 +1,23 @@
+//
+// 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 <uhd/usrp/usrp1e.hpp>
+
+#ifndef INCLUDED_USRP1E_IMPL_HPP
+#define INCLUDED_USRP1E_IMPL_HPP
+
+#endif /* INCLUDED_USRP1E_IMPL_HPP */
diff --git a/host/lib/usrp/usrp1e/usrp1e_none.cpp b/host/lib/usrp/usrp1e/usrp1e_none.cpp
new file mode 100644
index 000000000..ac0b12a75
--- /dev/null
+++ b/host/lib/usrp/usrp1e/usrp1e_none.cpp
@@ -0,0 +1,38 @@
+//
+// 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 <uhd/usrp/usrp1e.hpp>
+
+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
+}
+
+device::sptr usrp1e::make(const device_addr_t &){
+ throw std::runtime_error("this build has no usrp1e support");
+}
+
+void usrp1e::load_fpga(const std::string &){
+ 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..5aa5d6e8d 100644
--- a/host/lib/usrp/usrp2/usrp2_impl.cpp
+++ b/host/lib/usrp/usrp2/usrp2_impl.cpp
@@ -33,32 +33,35 @@ 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["addr"] = ip_addr.to_string();
usrp2_addrs.push_back(new_addr);
break;
@@ -72,21 +75,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 +98,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 +120,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 +128,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 +163,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 +208,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-11-18 22:36:36 +0000