diff options
Diffstat (limited to 'host/lib')
25 files changed, 2308 insertions, 0 deletions
diff --git a/host/lib/CMakeLists.txt b/host/lib/CMakeLists.txt new file mode 100644 index 000000000..295943a6f --- /dev/null +++ b/host/lib/CMakeLists.txt @@ -0,0 +1,43 @@ +# +# 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/>. +# + + +ADD_LIBRARY(uhd SHARED + device.cpp + device_addr.cpp + gain_handler.cpp + shared_iovec.cpp + uhd.cpp + wax.cpp + transport/udp.cpp + usrp/usrp.cpp + usrp/dboard/basic.cpp + usrp/dboard/base.cpp + usrp/dboard/id.cpp + usrp/dboard/interface.cpp + usrp/dboard/manager.cpp + usrp/mboard/base.cpp + usrp/mboard/test.cpp + usrp/mboard/usrp2.cpp + usrp/mboard/usrp2/impl_base.cpp + usrp/mboard/usrp2/dboard_impl.cpp + usrp/mboard/usrp2/dboard_interface.cpp +) + +TARGET_LINK_LIBRARIES(uhd ${Boost_LIBRARIES}) + +INSTALL(TARGETS uhd LIBRARY DESTINATION ${LIBRARY_DIR}) diff --git a/host/lib/device.cpp b/host/lib/device.cpp new file mode 100644 index 000000000..822733217 --- /dev/null +++ b/host/lib/device.cpp @@ -0,0 +1,74 @@ +// +// 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/usrp.hpp> +#include <uhd/usrp/mboard/usrp2.hpp> +#include <uhd/device.hpp> +#include <boost/format.hpp> +#include <stdexcept> + +using namespace uhd; + +device_addrs_t device::discover(const device_addr_t &hint){ + device_addrs_t device_addrs; + if (not hint.has_key("type")){ + //TODO nothing + } + else if (hint["type"] == "test"){ + //make a copy of the hint for testing + device_addr_t test_device_addr = hint; + device_addrs.push_back(test_device_addr); + } + else if (hint["type"] == "udp"){ + std::vector<device_addr_t> usrp2_addrs = usrp::mboard::usrp2::discover(hint); + device_addrs.insert(device_addrs.begin(), usrp2_addrs.begin(), usrp2_addrs.end()); + } + return device_addrs; +} + +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) + )); + } + + //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) + )); + } + + //create the new device with the discovered address + //TODO only a usrp device will be made (until others are supported) + if (true){ + return sptr(new uhd::usrp::usrp(device_addrs.at(which))); + } + throw std::runtime_error("cant make a device"); +} + +device::device(void){ + /* NOP */ +} + +device::~device(void){ + /* NOP */ +} diff --git a/host/lib/device_addr.cpp b/host/lib/device_addr.cpp new file mode 100644 index 000000000..ffd511f92 --- /dev/null +++ b/host/lib/device_addr.cpp @@ -0,0 +1,86 @@ +// +// 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/device_addr.hpp> +#include <sstream> +#include <cstring> +#include <stdexcept> +#include <boost/format.hpp> +#include <boost/algorithm/string.hpp> +#include <boost/foreach.hpp> + +//----------------------- u2 mac addr wrapper ------------------------// +uhd::mac_addr_t::mac_addr_t(const std::string &mac_addr_str_){ + std::string mac_addr_str = (mac_addr_str_ == "")? "ff:ff:ff:ff:ff:ff" : mac_addr_str_; + + //ether_aton_r(str.c_str(), &mac_addr); + uint8_t p[6] = {0x00, 0x50, 0xC2, 0x85, 0x30, 0x00}; // Matt's IAB + + try{ + //only allow patterns of xx:xx or xx:xx:xx:xx:xx:xx + //the IAB above will fill in for the shorter pattern + if (mac_addr_str.size() != 5 and mac_addr_str.size() != 17) + throw std::runtime_error("expected exactly 5 or 17 characters"); + + //split the mac addr hex string at the colons + std::vector<std::string> hex_strs; + boost::split(hex_strs, mac_addr_str, boost::is_any_of(":")); + for (size_t i = 0; i < hex_strs.size(); i++){ + int hex_num; + std::istringstream iss(hex_strs[i]); + iss >> std::hex >> hex_num; + p[i] = uint8_t(hex_num); + } + + } + catch(std::exception const& e){ + throw std::runtime_error(str( + boost::format("Invalid mac address: %s\n\t%s") % mac_addr_str % e.what() + )); + } + + memcpy(&mac_addr, p, sizeof(mac_addr)); +} + +std::string uhd::mac_addr_t::to_string(void) const{ + //ether_ntoa_r(&mac_addr, addr_buf); + const uint8_t *p = reinterpret_cast<const uint8_t *>(&mac_addr); + return str( + boost::format("%02x:%02x:%02x:%02x:%02x:%02x") + % int(p[0]) % int(p[1]) % int(p[2]) + % int(p[3]) % int(p[4]) % int(p[5]) + ); +} + +std::ostream& operator<<(std::ostream &os, const uhd::mac_addr_t &x){ + os << x.to_string(); + return os; +} + +//----------------------- usrp device_addr_t wrapper -------------------------// +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; + } + return ss.str(); +} + +std::ostream& operator<<(std::ostream &os, const uhd::device_addr_t &device_addr){ + os << uhd::device_addr_to_string(device_addr); + return os; +} diff --git a/host/lib/gain_handler.cpp b/host/lib/gain_handler.cpp new file mode 100644 index 000000000..b03d5bda2 --- /dev/null +++ b/host/lib/gain_handler.cpp @@ -0,0 +1,167 @@ +// +// 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/gain_handler.hpp> +#include <uhd/utils.hpp> +#include <boost/assign/list_of.hpp> +#include <boost/foreach.hpp> +#include <boost/format.hpp> +#include <vector> + +using namespace uhd; + +/*********************************************************************** + * Helper functions and macros + **********************************************************************/ +#define GET_PROP_NAMES() \ + wax::cast<prop_names_t>((*_wax_obj_ptr)[_gain_names_prop]) + +/*! + * Helper function to simplify getting a named gain (also min, max, step). + */ +static gain_t get_named_gain(wax::obj *wax_obj_ptr, wax::obj prop, std::string name){ + return wax::cast<gain_t>((*wax_obj_ptr)[named_prop_t(prop, name)]); +} + +/*********************************************************************** + * Class methods of gain handler + **********************************************************************/ +gain_handler::~gain_handler(void){ + /* NOP */ +} + +void gain_handler::_check_key(const wax::obj &key_){ + wax::obj key; std::string name; + boost::tie(key, name) = extract_named_prop(key_); + + try{ + //only handle non wildcard names + ASSERT_THROW(name != ""); + + //only handle these gain props + ASSERT_THROW( + _is_equal(key, _gain_prop) or + _is_equal(key, _gain_min_prop) or + _is_equal(key, _gain_max_prop) or + _is_equal(key, _gain_step_prop) + ); + + //check that the name is allowed + prop_names_t prop_names = GET_PROP_NAMES(); + ASSERT_THROW(not std::has(prop_names.begin(), prop_names.end(), name)); + + //if we get here, throw an exception + throw std::invalid_argument(str( + boost::format("Unknown gain name %s") % name + )); + } + catch(const std::assert_error &){} +} + +static gain_t gain_max(gain_t a, gain_t b){ + return std::max(a, b); +} +static gain_t gain_sum(gain_t a, gain_t b){ + return std::sum(a, b); +} + +bool gain_handler::intercept_get(const wax::obj &key, wax::obj &val){ + _check_key(key); //verify the key + + std::vector<wax::obj> gain_props = boost::assign::list_of + (_gain_prop)(_gain_min_prop)(_gain_max_prop)(_gain_step_prop); + + /*! + * Handle getting overall gains when a name is not specified. + * For the gain props below, set the overall value and return true. + */ + BOOST_FOREACH(wax::obj prop_key, gain_props){ + if (_is_equal(key, prop_key)){ + //form the gains vector from the props vector + prop_names_t prop_names = GET_PROP_NAMES(); + std::vector<gain_t> gains(prop_names.size()); + std::transform( + prop_names.begin(), prop_names.end(), gains.begin(), + boost::bind(get_named_gain, _wax_obj_ptr, key, _1) + ); + + //reduce across the gain vector + if (_is_equal(key, _gain_step_prop)){ + val = std::reduce<gain_t>(gains.begin(), gains.end(), gain_max); + } + else{ + val = std::reduce<gain_t>(gains.begin(), gains.end(), gain_sum); + } + return true; + } + } + + return false; +} + +bool gain_handler::intercept_set(const wax::obj &key_, const wax::obj &val){ + _check_key(key_); //verify the key + + wax::obj key; std::string name; + boost::tie(key, name) = extract_named_prop(key_); + + /*! + * Verify that a named gain component is in range. + */ + try{ + //only handle the gain props + ASSERT_THROW(_is_equal(key, _gain_prop)); + + //check that the gain is in range + gain_t gain = wax::cast<gain_t>(val); + gain_t gain_min = get_named_gain(_wax_obj_ptr, _gain_min_prop, name); + gain_t gain_max = get_named_gain(_wax_obj_ptr, _gain_max_prop, name); + ASSERT_THROW(gain > gain_max or gain < gain_min); + + //if we get here, throw an exception + throw std::range_error(str( + boost::format("gain %s is out of range of (%f, %f)") % name % gain_min % gain_max + )); + } + catch(const std::assert_error &){} + + /*! + * Handle setting the overall gain. + */ + if (_is_equal(key, _gain_prop) and name == ""){ + gain_t gain = wax::cast<gain_t>(val); + prop_names_t prop_names = GET_PROP_NAMES(); + BOOST_FOREACH(std::string name, prop_names){ + //get the min, max, step for this gain name + gain_t gain_min = get_named_gain(_wax_obj_ptr, _gain_min_prop, name); + gain_t gain_max = get_named_gain(_wax_obj_ptr, _gain_max_prop, name); + gain_t gain_step = get_named_gain(_wax_obj_ptr, _gain_step_prop, name); + + //clip g to be within the allowed range + gain_t g = std::min(std::max(gain, gain_min), gain_max); + //set g to be a multiple of the step size + g -= fmod(g, gain_step); + //set g to be the new gain + (*_wax_obj_ptr)[named_prop_t(_gain_prop, name)] = g; + //subtract g out of the total gain left to apply + gain -= g; + } + return true; + } + + return false; +} diff --git a/host/lib/shared_iovec.cpp b/host/lib/shared_iovec.cpp new file mode 100644 index 000000000..60062fbf0 --- /dev/null +++ b/host/lib/shared_iovec.cpp @@ -0,0 +1,28 @@ +// +// 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/shared_iovec.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_; +} + +uhd::shared_iovec::~shared_iovec(void){ + /* NOP */ +} diff --git a/host/lib/transport/udp.cpp b/host/lib/transport/udp.cpp new file mode 100644 index 000000000..06defb107 --- /dev/null +++ b/host/lib/transport/udp.cpp @@ -0,0 +1,67 @@ +// +// 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/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){ + //std::cout << boost::format("Creating udp transport for %s %s") % addr % port << std::endl; + + // resolve the address + boost::asio::ip::udp::resolver resolver(_io_service); + boost::asio::ip::udp::resolver::query query(boost::asio::ip::udp::v4(), addr, port); + _receiver_endpoint = *resolver.resolve(query); + + // Create and open the socket + _socket = new boost::asio::ip::udp::socket(_io_service); + _socket->open(boost::asio::ip::udp::v4()); + + if (bcast){ + // Allow broadcasting + boost::asio::socket_base::broadcast option(true); + _socket->set_option(option); + } + +} + +uhd::transport::udp::~udp(void){ + delete _socket; +} + +void uhd::transport::udp::send(const std::vector<boost::asio::const_buffer> &buffs){ + _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); +} + +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; +} diff --git a/host/lib/uhd.cpp b/host/lib/uhd.cpp new file mode 100644 index 000000000..5e250c76f --- /dev/null +++ b/host/lib/uhd.cpp @@ -0,0 +1,20 @@ +// +// 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.hpp> + +//nothing here, just includes the header so the compiler can check diff --git a/host/lib/usrp/dboard/base.cpp b/host/lib/usrp/dboard/base.cpp new file mode 100644 index 000000000..de8db323a --- /dev/null +++ b/host/lib/usrp/dboard/base.cpp @@ -0,0 +1,89 @@ +// +// 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/dboard/base.hpp> +#include <stdexcept> + +using namespace uhd::usrp::dboard; + +/*********************************************************************** + * base dboard base class + **********************************************************************/ +base::base(ctor_args_t const& args){ + boost::tie(_subdev_name, _dboard_interface) = args; +} + +base::~base(void){ + /* NOP */ +} + +std::string base::get_subdev_name(void){ + return _subdev_name; +} + +interface::sptr base::get_interface(void){ + return _dboard_interface; +} + +/*********************************************************************** + * xcvr dboard base class + **********************************************************************/ +xcvr_base::xcvr_base(ctor_args_t const& args) : base(args){ + /* NOP */ +} + +xcvr_base::~xcvr_base(void){ + /* NOP */ +} + +/*********************************************************************** + * rx dboard base class + **********************************************************************/ +rx_base::rx_base(ctor_args_t const& args) : base(args){ + /* NOP */ +} + +rx_base::~rx_base(void){ + /* NOP */ +} + +void rx_base::tx_get(const wax::obj &, wax::obj &){ + throw std::runtime_error("cannot call tx_get on a rx dboard"); +} + +void rx_base::tx_set(const wax::obj &, const wax::obj &){ + throw std::runtime_error("cannot call tx_set on a rx dboard"); +} + +/*********************************************************************** + * tx dboard base class + **********************************************************************/ +tx_base::tx_base(ctor_args_t const& args) : base(args){ + /* NOP */ +} + +tx_base::~tx_base(void){ + /* NOP */ +} + +void tx_base::rx_get(const wax::obj &, wax::obj &){ + throw std::runtime_error("cannot call rx_get on a tx dboard"); +} + +void tx_base::rx_set(const wax::obj &, const wax::obj &){ + throw std::runtime_error("cannot call rx_set on a tx dboard"); +} diff --git a/host/lib/usrp/dboard/basic.cpp b/host/lib/usrp/dboard/basic.cpp new file mode 100644 index 000000000..35512aa5f --- /dev/null +++ b/host/lib/usrp/dboard/basic.cpp @@ -0,0 +1,56 @@ +// +// 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 "dboards.hpp" + +/*********************************************************************** + * Basic RX dboard + **********************************************************************/ +basic_rx::basic_rx(ctor_args_t const& args) : rx_base(args){ + /* NOP */ +} + +basic_rx::~basic_rx(void){ + /* NOP */ +} + +void basic_rx::rx_get(const wax::obj &, wax::obj &){ + /* TODO */ +} + +void basic_rx::rx_set(const wax::obj &, const wax::obj &){ + /* TODO */ +} + +/*********************************************************************** + * Basic TX dboard + **********************************************************************/ +basic_tx::basic_tx(ctor_args_t const& args) : tx_base(args){ + /* NOP */ +} + +basic_tx::~basic_tx(void){ + /* NOP */ +} + +void basic_tx::tx_get(const wax::obj &, wax::obj &){ + /* TODO */ +} + +void basic_tx::tx_set(const wax::obj &, const wax::obj &){ + /* TODO */ +} diff --git a/host/lib/usrp/dboard/dboards.hpp b/host/lib/usrp/dboard/dboards.hpp new file mode 100644 index 000000000..0e740856f --- /dev/null +++ b/host/lib/usrp/dboard/dboards.hpp @@ -0,0 +1,53 @@ +// +// 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_LOCAL_DBOARDS_HPP +#define INCLUDED_LOCAL_DBOARDS_HPP + +#include <uhd/usrp/dboard/base.hpp> + +using namespace uhd::usrp::dboard; + +/*********************************************************************** + * The basic boards: + **********************************************************************/ +class basic_rx : public rx_base{ +public: + static base::sptr make(ctor_args_t const& args){ + return base::sptr(new basic_rx(args)); + } + basic_rx(ctor_args_t const& args); + ~basic_rx(void); + + void rx_get(const wax::obj &key, wax::obj &val); + void rx_set(const wax::obj &key, const wax::obj &val); +}; + +class basic_tx : public tx_base{ +public: + static base::sptr make(ctor_args_t const& args){ + return base::sptr(new basic_tx(args)); + } + basic_tx(ctor_args_t const& args); + ~basic_tx(void); + + void tx_get(const wax::obj &key, wax::obj &val); + void tx_set(const wax::obj &key, const wax::obj &val); + +}; + +#endif /* INCLUDED_LOCAL_DBOARDS_HPP */ diff --git a/host/lib/usrp/dboard/id.cpp b/host/lib/usrp/dboard/id.cpp new file mode 100644 index 000000000..80162240e --- /dev/null +++ b/host/lib/usrp/dboard/id.cpp @@ -0,0 +1,39 @@ +// +// 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/dboard/id.hpp> +#include <boost/format.hpp> +#include <uhd/dict.hpp> + +using namespace uhd::usrp::dboard; + +std::ostream& operator<<(std::ostream &os, const dboard_id_t &id){ + //map the dboard ids to string representations + uhd::dict<dboard_id_t, std::string> id_to_str; + id_to_str[ID_NONE] = "none"; + id_to_str[ID_BASIC_TX] = "basic tx"; + id_to_str[ID_BASIC_RX] = "basic rx"; + + //get the string representation + if (id_to_str.has_key(id)){ + os << id_to_str[id]; + } + else{ + os << boost::format("dboard id %u") % unsigned(id); + } + return os; +} diff --git a/host/lib/usrp/dboard/interface.cpp b/host/lib/usrp/dboard/interface.cpp new file mode 100644 index 000000000..837c76d0a --- /dev/null +++ b/host/lib/usrp/dboard/interface.cpp @@ -0,0 +1,28 @@ +// +// 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/dboard/interface.hpp> + +using namespace uhd::usrp::dboard; + +interface::interface(void){ + /* NOP */ +} + +interface::~interface(void){ + /* NOP */ +} diff --git a/host/lib/usrp/dboard/manager.cpp b/host/lib/usrp/dboard/manager.cpp new file mode 100644 index 000000000..4a675fd0b --- /dev/null +++ b/host/lib/usrp/dboard/manager.cpp @@ -0,0 +1,205 @@ +// +// 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/dboard/manager.hpp> +#include <boost/assign/list_of.hpp> +#include <boost/format.hpp> +#include <boost/foreach.hpp> +#include "dboards.hpp" + +using namespace uhd; +using namespace uhd::usrp::dboard; +using namespace boost::assign; + +/*********************************************************************** + * register internal dboards + * + * Register internal/known dboards located in this build tree. + * Each board should have entries below mapping an id to a constructor. + * The xcvr type boards should register both rx and tx sides. + * + * This function will be called before new boards are registered. + * This allows for internal boards to be externally overridden. + * This function will also be called when creating a new manager + * to ensure that the maps are filled with the entries below. + **********************************************************************/ +static void register_internal_dboards(void){ + //ensure that this function can only be called once per instance + static bool called = false; + if (called) return; called = true; + //register the known dboards (dboard id, constructor, subdev names) + manager::register_subdevs(ID_NONE, &basic_tx::make, list_of("")); //for none, make a basic tx + manager::register_subdevs(ID_NONE, &basic_rx::make, list_of("ab")); //for none, make a basic rx (one subdev) + manager::register_subdevs(ID_BASIC_TX, &basic_tx::make, list_of("")); + manager::register_subdevs(ID_BASIC_RX, &basic_rx::make, list_of("a")("b")("ab")); +} + +/*********************************************************************** + * storage and registering for dboards + **********************************************************************/ +//map a dboard id to a dboard constructor +static uhd::dict<dboard_id_t, manager::dboard_ctor_t> id_to_ctor_map; + +//map a dboard constructor to subdevice names +static uhd::dict<manager::dboard_ctor_t, prop_names_t> ctor_to_names_map; + +void manager::register_subdevs( + dboard_id_t dboard_id, + dboard_ctor_t dboard_ctor, + const prop_names_t &subdev_names +){ + register_internal_dboards(); //always call first + id_to_ctor_map[dboard_id] = dboard_ctor; + ctor_to_names_map[dboard_ctor] = subdev_names; +} + +/*********************************************************************** + * internal helper classes + **********************************************************************/ +/*! + * A special wax proxy object that forwards calls to a subdev. + * A sptr to an instance will be used in the properties structure. + */ +class subdev_proxy : boost::noncopyable, public wax::obj{ +public: + typedef boost::shared_ptr<subdev_proxy> sptr; + enum type_t{RX_TYPE, TX_TYPE}; + + //structors + subdev_proxy(base::sptr subdev, type_t type) + : _subdev(subdev), _type(type){ + /* NOP */ + } + + ~subdev_proxy(void){ + /* NOP */ + } + +private: + base::sptr _subdev; + type_t _type; + + //forward the get calls to the rx or tx + void get(const wax::obj &key, wax::obj &val){ + switch(_type){ + case RX_TYPE: return _subdev->rx_get(key, val); + case TX_TYPE: return _subdev->tx_get(key, val); + } + } + + //forward the set calls to the rx or tx + void set(const wax::obj &key, const wax::obj &val){ + switch(_type){ + case RX_TYPE: return _subdev->rx_set(key, val); + case TX_TYPE: return _subdev->tx_set(key, val); + } + } +}; + +/*********************************************************************** + * dboard manager methods + **********************************************************************/ +static manager::dboard_ctor_t const& get_dboard_ctor( + dboard_id_t dboard_id, + std::string const& xx_type +){ + //verify that there is a registered constructor for this id + if (not id_to_ctor_map.has_key(dboard_id)){ + throw std::runtime_error(str( + boost::format("Unknown %s dboard id: 0x%04x") % xx_type % dboard_id + )); + } + //return the dboard constructor for this id + return id_to_ctor_map[dboard_id]; +} + +manager::manager( + dboard_id_t rx_dboard_id, + dboard_id_t tx_dboard_id, + interface::sptr dboard_interface +){ + register_internal_dboards(); //always call first + const dboard_ctor_t rx_dboard_ctor = get_dboard_ctor(rx_dboard_id, "rx"); + const dboard_ctor_t tx_dboard_ctor = get_dboard_ctor(tx_dboard_id, "tx"); + //make xcvr subdevs (make one subdev for both rx and tx dboards) + if (rx_dboard_ctor == tx_dboard_ctor){ + BOOST_FOREACH(std::string name, ctor_to_names_map[rx_dboard_ctor]){ + base::sptr xcvr_dboard = rx_dboard_ctor( + base::ctor_args_t(name, dboard_interface) + ); + //create a rx proxy for this xcvr board + _rx_dboards[name] = subdev_proxy::sptr( + new subdev_proxy(xcvr_dboard, subdev_proxy::RX_TYPE) + ); + //create a tx proxy for this xcvr board + _tx_dboards[name] = subdev_proxy::sptr( + new subdev_proxy(xcvr_dboard, subdev_proxy::TX_TYPE) + ); + } + } + //make tx and rx subdevs (separate subdevs for rx and tx dboards) + else{ + //make the rx subdevs + BOOST_FOREACH(std::string name, ctor_to_names_map[rx_dboard_ctor]){ + base::sptr rx_dboard = rx_dboard_ctor( + base::ctor_args_t(name, dboard_interface) + ); + //create a rx proxy for this rx board + _rx_dboards[name] = subdev_proxy::sptr( + new subdev_proxy(rx_dboard, subdev_proxy::RX_TYPE) + ); + } + //make the tx subdevs + BOOST_FOREACH(std::string name, ctor_to_names_map[tx_dboard_ctor]){ + base::sptr tx_dboard = tx_dboard_ctor( + base::ctor_args_t(name, dboard_interface) + ); + //create a tx proxy for this tx board + _tx_dboards[name] = subdev_proxy::sptr( + new subdev_proxy(tx_dboard, subdev_proxy::TX_TYPE) + ); + } + } +} + +manager::~manager(void){ + /* NOP */ +} + +prop_names_t manager::get_rx_subdev_names(void){ + return _rx_dboards.get_keys(); +} + +prop_names_t manager::get_tx_subdev_names(void){ + return _tx_dboards.get_keys(); +} + +wax::obj manager::get_rx_subdev(const std::string &subdev_name){ + if (not _rx_dboards.has_key(subdev_name)) throw std::invalid_argument( + str(boost::format("Unknown rx subdev name %s") % subdev_name) + ); + //get a link to the rx subdev proxy + return wax::cast<subdev_proxy::sptr>(_rx_dboards[subdev_name])->get_link(); +} + +wax::obj manager::get_tx_subdev(const std::string &subdev_name){ + if (not _tx_dboards.has_key(subdev_name)) throw std::invalid_argument( + str(boost::format("Unknown tx subdev name %s") % subdev_name) + ); + //get a link to the tx subdev proxy + return wax::cast<subdev_proxy::sptr>(_tx_dboards[subdev_name])->get_link(); +} diff --git a/host/lib/usrp/mboard/base.cpp b/host/lib/usrp/mboard/base.cpp new file mode 100644 index 000000000..f4f0324f3 --- /dev/null +++ b/host/lib/usrp/mboard/base.cpp @@ -0,0 +1,29 @@ +// +// 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/mboard/base.hpp> +#include <stdexcept> + +using namespace uhd::usrp::mboard; + +base::base(void){ + /* NOP */ +} + +base::~base(void){ + /* NOP */ +} diff --git a/host/lib/usrp/mboard/test.cpp b/host/lib/usrp/mboard/test.cpp new file mode 100644 index 000000000..67d3c70fa --- /dev/null +++ b/host/lib/usrp/mboard/test.cpp @@ -0,0 +1,188 @@ +// +// 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/mboard/test.hpp> +#include <uhd/props.hpp> +#include <boost/lexical_cast.hpp> +#include <boost/format.hpp> +#include <stdexcept> + +using namespace uhd; +using namespace uhd::usrp; +using namespace uhd::usrp::mboard; + +/*********************************************************************** + * dummy interface for dboards + **********************************************************************/ +class dummy_interface : public uhd::usrp::dboard::interface{ +public: + dummy_interface(void){} + ~dummy_interface(void){} + void write_aux_dac(int, int){} + int read_aux_adc(int){return 0;} + void set_atr_reg(gpio_bank_t, uint16_t, uint16_t, uint16_t){} + void set_gpio_ddr(gpio_bank_t, uint16_t, uint16_t){} + void write_gpio(gpio_bank_t, uint16_t, uint16_t){} + uint16_t read_gpio(gpio_bank_t){return 0;} + void write_i2c (int, const std::string &){} + std::string read_i2c (int, size_t){return "";} + void write_spi (spi_dev_t, spi_push_t, const std::string &){} + std::string read_spi (spi_dev_t, spi_latch_t, size_t){return "";} + double get_rx_clock_rate(void){return 0.0;} + double get_tx_clock_rate(void){return 0.0;} +}; + +/*********************************************************************** + * shell class to act as a dboard + **********************************************************************/ +class shell_dboard : public wax::obj{ +public: + enum type_t {TYPE_RX, TYPE_TX}; + shell_dboard(dboard::manager::sptr mgr, type_t type){ + _mgr = mgr; + _type = type; + } + ~shell_dboard(void){} +private: + void get(const wax::obj &key_, wax::obj &val){ + wax::obj key; std::string name; + boost::tie(key, name) = extract_named_prop(key_); + + //handle the get request conditioned on the key + switch(wax::cast<dboard_prop_t>(key)){ + case DBOARD_PROP_NAME: + val = std::string("dboard test mboard"); + return; + + case DBOARD_PROP_SUBDEV: + switch(_type){ + case TYPE_RX: + val = _mgr->get_rx_subdev(name); + return; + + case TYPE_TX: + val = _mgr->get_tx_subdev(name); + return; + } + + case DBOARD_PROP_SUBDEV_NAMES: + switch(_type){ + case TYPE_RX: + val = _mgr->get_rx_subdev_names(); + return; + + case TYPE_TX: + val = _mgr->get_tx_subdev_names(); + return; + } + + case DBOARD_PROP_CODEC: + return; + } + } + + void set(const wax::obj &, const wax::obj &){ + throw std::runtime_error("Cannot set on usrp test dboard"); + } + + type_t _type; + dboard::manager::sptr _mgr; +}; + +/*********************************************************************** + * test usrp mboard class + **********************************************************************/ +test::test(const device_addr_t &device_addr){ + //extract the number of dboards + size_t num_dboards = boost::lexical_cast<size_t>(device_addr["num_dboards"]); + //create a manager for each dboard + for (size_t i = 0; i < num_dboards; i++){ + dboard::interface::sptr ifc(new dummy_interface()); + _dboard_managers[boost::lexical_cast<std::string>(i)] = dboard::manager::sptr( + new dboard::manager(dboard::ID_BASIC_RX, dboard::ID_BASIC_TX, ifc) + ); + } +} + +test::~test(void){ + /* NOP */ +} + +void test::get(const wax::obj &key_, wax::obj &val){ + wax::obj key; std::string name; + boost::tie(key, name) = extract_named_prop(key_); + + //handle the get request conditioned on the key + switch(wax::cast<mboard_prop_t>(key)){ + case MBOARD_PROP_NAME: + val = std::string("usrp test mboard"); + return; + + case MBOARD_PROP_OTHERS: + val = prop_names_t(); //empty other props + return; + + case MBOARD_PROP_RX_DBOARD: + if (not _dboard_managers.has_key(name)) throw std::invalid_argument( + str(boost::format("Unknown rx dboard name %s") % name) + ); + //FIXME store the shell dboard within the class + //may not fix, plan to remove this test class when real usrps work + //val = wax::obj::sptr( + // new shell_dboard(_dboard_managers[name], shell_dboard::TYPE_RX) + //); + return; + + case MBOARD_PROP_RX_DBOARD_NAMES: + val = prop_names_t(_dboard_managers.get_keys()); + return; + + case MBOARD_PROP_TX_DBOARD: + if (not _dboard_managers.has_key(name)) throw std::invalid_argument( + str(boost::format("Unknown tx dboard name %s") % name) + ); + //FIXME store the shell dboard within the class + //may not fix, plan to remove this test class when real usrps work + //val = wax::obj::sptr( + // new shell_dboard(_dboard_managers[name], shell_dboard::TYPE_TX) + //); + return; + + case MBOARD_PROP_TX_DBOARD_NAMES: + val = prop_names_t(_dboard_managers.get_keys()); + return; + + case MBOARD_PROP_MTU: + case MBOARD_PROP_CLOCK_RATE: + case MBOARD_PROP_RX_DSP: + case MBOARD_PROP_RX_DSP_NAMES: + case MBOARD_PROP_TX_DSP: + case MBOARD_PROP_TX_DSP_NAMES: + case MBOARD_PROP_PPS_SOURCE: + case MBOARD_PROP_PPS_SOURCE_NAMES: + case MBOARD_PROP_PPS_POLARITY: + case MBOARD_PROP_REF_SOURCE: + case MBOARD_PROP_REF_SOURCE_NAMES: + case MBOARD_PROP_TIME_NOW: + case MBOARD_PROP_TIME_NEXT_PPS: + throw std::runtime_error("unhandled prop is usrp test mboard"); + } +} + +void test::set(const wax::obj &, const wax::obj &){ + throw std::runtime_error("Cannot set on usrp test mboard"); +} diff --git a/host/lib/usrp/mboard/usrp2.cpp b/host/lib/usrp/mboard/usrp2.cpp new file mode 100644 index 000000000..92f4daa49 --- /dev/null +++ b/host/lib/usrp/mboard/usrp2.cpp @@ -0,0 +1,116 @@ +// +// 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/mboard/usrp2.hpp> +#include <uhd/device.hpp> +#include <uhd/transport/udp.hpp> +#include <boost/lexical_cast.hpp> +#include <boost/format.hpp> +#include <boost/thread.hpp> +#include <netinet/in.h> +#include "usrp2/impl_base.hpp" + +using namespace uhd::usrp::mboard; + +/*********************************************************************** + * Discovery over the udp transport + **********************************************************************/ +uhd::device_addrs_t usrp2::discover(const device_addr_t &hint){ + device_addrs_t 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); + uhd::transport::udp udp_transport(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))); + + //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)){ + //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)){ + 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)); + device_addr_t new_addr; + new_addr["name"] = "USRP2"; + new_addr["type"] = "udp"; + new_addr["addr"] = ip_addr.to_string(); + usrp2_addrs.push_back(new_addr); + break; + } + } + } + + return usrp2_addrs; +} + +/*********************************************************************** + * Structors + **********************************************************************/ +usrp2::usrp2(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) + ) + ); + + //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) + ) + ); + + //create the usrp2 implementation guts + _impl = impl_base::sptr( + new impl_base(ctrl_transport, data_transport) + ); +} + +usrp2::~usrp2(void){ + /* NOP */ +} + +/*********************************************************************** + * Get Properties + **********************************************************************/ +void usrp2::get(const wax::obj &key, wax::obj &val){ + return wax::cast<impl_base::sptr>(_impl)->get(key, val); +} + +/*********************************************************************** + * Set Properties + **********************************************************************/ +void usrp2::set(const wax::obj &key, const wax::obj &val){ + return wax::cast<impl_base::sptr>(_impl)->set(key, val); +} diff --git a/host/lib/usrp/mboard/usrp2/dboard_impl.cpp b/host/lib/usrp/mboard/usrp2/dboard_impl.cpp new file mode 100644 index 000000000..309335cc7 --- /dev/null +++ b/host/lib/usrp/mboard/usrp2/dboard_impl.cpp @@ -0,0 +1,76 @@ +// +// 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 <boost/format.hpp> +#include <uhd/utils.hpp> +#include <uhd/props.hpp> +#include <iostream> +#include "dboard_impl.hpp" +#include "dboard_interface.hpp" + +using namespace uhd; +using namespace uhd::usrp; + +dboard_impl::dboard_impl(uhd::usrp::dboard::manager::sptr mgr, type_t type){ + _mgr = mgr; + _type = type; +} + +dboard_impl::~dboard_impl(void){ + /* NOP */ +} + +void dboard_impl::get(const wax::obj &key_, wax::obj &val){ + wax::obj key; std::string name; + boost::tie(key, name) = extract_named_prop(key_); + + //handle the get request conditioned on the key + switch(wax::cast<dboard_prop_t>(key)){ + case DBOARD_PROP_NAME: + val = std::string("usrp2 dboard"); + return; + + case DBOARD_PROP_SUBDEV: + switch(_type){ + case TYPE_RX: + val = _mgr->get_rx_subdev(name); + return; + + case TYPE_TX: + val = _mgr->get_tx_subdev(name); + return; + } + + case DBOARD_PROP_SUBDEV_NAMES: + switch(_type){ + case TYPE_RX: + val = _mgr->get_rx_subdev_names(); + return; + + case TYPE_TX: + val = _mgr->get_tx_subdev_names(); + return; + } + + case DBOARD_PROP_CODEC: + throw std::runtime_error("unhandled prop in usrp2 dboard"); + } +} + +void dboard_impl::set(const wax::obj &, const wax::obj &){ + throw std::runtime_error("Cannot set on usrp2 dboard"); +} diff --git a/host/lib/usrp/mboard/usrp2/dboard_impl.hpp b/host/lib/usrp/mboard/usrp2/dboard_impl.hpp new file mode 100644 index 000000000..a05bcd07b --- /dev/null +++ b/host/lib/usrp/mboard/usrp2/dboard_impl.hpp @@ -0,0 +1,50 @@ +// +// 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/dboard/manager.hpp> +#include <boost/utility.hpp> +#include <boost/shared_ptr.hpp> +#include "fw_common.h" + +#ifndef INCLUDED_DBOARD_IMPL_HPP +#define INCLUDED_DBOARD_IMPL_HPP + +/*! + * The usrp2 dboard implementation: + * Provide the properties access for a dboard. + * Internally, hold a dboard manager and the direction. + * The usrp2 mboard base implementation will create + * two of these classes (one for rx and one for tx). + */ +class dboard_impl : boost::noncopyable, public wax::obj{ +public: + typedef boost::shared_ptr<dboard_impl> sptr; + enum type_t {TYPE_RX, TYPE_TX}; + + dboard_impl(uhd::usrp::dboard::manager::sptr manager, type_t type); + + ~dboard_impl(void); + + void get(const wax::obj &, wax::obj &); + void set(const wax::obj &, const wax::obj &); + +private: + uhd::usrp::dboard::manager::sptr _mgr; + type_t _type; +}; + +#endif /* INCLUDED_DBOARD_IMPL_HPP */ diff --git a/host/lib/usrp/mboard/usrp2/dboard_interface.cpp b/host/lib/usrp/mboard/usrp2/dboard_interface.cpp new file mode 100644 index 000000000..05d29daef --- /dev/null +++ b/host/lib/usrp/mboard/usrp2/dboard_interface.cpp @@ -0,0 +1,111 @@ +// +// 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/utils.hpp> +#include "dboard_interface.hpp" +#include "fw_common.h" + +/*********************************************************************** + * Structors + **********************************************************************/ +dboard_interface::dboard_interface(impl_base *impl){ + _impl = impl; +} + +dboard_interface::~dboard_interface(void){ + /* NOP */ +} + +/*********************************************************************** + * Clock Rates + **********************************************************************/ +double dboard_interface::get_rx_clock_rate(void){ + return _impl->get_master_clock_freq(); +} + +double dboard_interface::get_tx_clock_rate(void){ + return _impl->get_master_clock_freq(); +} + +/*********************************************************************** + * GPIO + **********************************************************************/ +/*! + * Static function to convert a gpio bank enum + * to an over-the-wire value for the usrp2 control. + * \param bank the dboard interface gpio bank enum + * \return an over the wire representation + */ +static uint8_t gpio_bank_to_otw(uhd::usrp::dboard::interface::gpio_bank_t bank){ + switch(bank){ + case uhd::usrp::dboard::interface::GPIO_TX_BANK: return USRP2_GPIO_BANK_TX; + case uhd::usrp::dboard::interface::GPIO_RX_BANK: return USRP2_GPIO_BANK_RX; + } + throw std::runtime_error("unknown gpio bank"); +} + +void dboard_interface::set_gpio_ddr(gpio_bank_t bank, uint16_t value, uint16_t mask){ + //setup the out data + usrp2_ctrl_data_t out_data; + out_data.id = htonl(USRP2_CTRL_ID_USE_THESE_GPIO_DDR_SETTINGS_BRO); + out_data.data.gpio_config.bank = gpio_bank_to_otw(bank); + out_data.data.gpio_config.value = htons(value); + out_data.data.gpio_config.mask = htons(mask); + + //send and recv + usrp2_ctrl_data_t in_data = _impl->ctrl_send_and_recv(out_data); + ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_GOT_THE_GPIO_DDR_SETTINGS_DUDE); +} + +void dboard_interface::write_gpio(gpio_bank_t bank, uint16_t value, uint16_t mask){ + //setup the out data + usrp2_ctrl_data_t out_data; + out_data.id = htonl(USRP2_CTRL_ID_SET_YOUR_GPIO_PIN_OUTS_BRO); + out_data.data.gpio_config.bank = gpio_bank_to_otw(bank); + out_data.data.gpio_config.value = htons(value); + out_data.data.gpio_config.mask = htons(mask); + + //send and recv + usrp2_ctrl_data_t in_data = _impl->ctrl_send_and_recv(out_data); + ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_I_SET_THE_GPIO_PIN_OUTS_DUDE); +} + +uint16_t dboard_interface::read_gpio(gpio_bank_t bank){ + //setup the out data + usrp2_ctrl_data_t out_data; + out_data.id = htonl(USRP2_CTRL_ID_GIVE_ME_YOUR_GPIO_PIN_VALS_BRO); + out_data.data.gpio_config.bank = gpio_bank_to_otw(bank); + + //send and recv + usrp2_ctrl_data_t in_data = _impl->ctrl_send_and_recv(out_data); + ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_HERE_IS_YOUR_GPIO_PIN_VALS_DUDE); + return ntohs(in_data.data.gpio_config.value); +} + +void dboard_interface::set_atr_reg(gpio_bank_t bank, uint16_t tx_value, uint16_t rx_value, uint16_t mask){ + //setup the out data + usrp2_ctrl_data_t out_data; + out_data.id = htonl(USRP2_CTRL_ID_USE_THESE_ATR_SETTINGS_BRO); + out_data.data.atr_config.bank = gpio_bank_to_otw(bank); + out_data.data.atr_config.tx_value = htons(tx_value); + out_data.data.atr_config.rx_value = htons(rx_value); + out_data.data.atr_config.mask = htons(mask); + + //send and recv + usrp2_ctrl_data_t in_data = _impl->ctrl_send_and_recv(out_data); + ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_GOT_THE_ATR_SETTINGS_DUDE); +} diff --git a/host/lib/usrp/mboard/usrp2/dboard_interface.hpp b/host/lib/usrp/mboard/usrp2/dboard_interface.hpp new file mode 100644 index 000000000..645681f43 --- /dev/null +++ b/host/lib/usrp/mboard/usrp2/dboard_interface.hpp @@ -0,0 +1,58 @@ +// +// 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/dboard/interface.hpp> +#include "impl_base.hpp" + +#ifndef INCLUDED_DBOARD_INTERFACE_HPP +#define INCLUDED_DBOARD_INTERFACE_HPP + +class dboard_interface : public uhd::usrp::dboard::interface{ +public: + dboard_interface(impl_base *impl); + + ~dboard_interface(void); + + void write_aux_dac(int, int){} + + int read_aux_adc(int){return 0;} + + void set_atr_reg(gpio_bank_t, uint16_t, uint16_t, uint16_t); + + void set_gpio_ddr(gpio_bank_t, uint16_t, uint16_t); + + void write_gpio(gpio_bank_t, uint16_t, uint16_t); + + uint16_t read_gpio(gpio_bank_t); + + void write_i2c (int, const std::string &){} + + std::string read_i2c (int, size_t){return "";} + + void write_spi (spi_dev_t, spi_push_t, const std::string &){} + + std::string read_spi (spi_dev_t, spi_latch_t, size_t){return "";} + + double get_rx_clock_rate(void); + + double get_tx_clock_rate(void); + +private: + impl_base *_impl; +}; + +#endif /* INCLUDED_DBOARD_INTERFACE_HPP */ diff --git a/host/lib/usrp/mboard/usrp2/fw_common.h b/host/lib/usrp/mboard/usrp2/fw_common.h new file mode 100644 index 000000000..8cd15c7c3 --- /dev/null +++ b/host/lib/usrp/mboard/usrp2/fw_common.h @@ -0,0 +1,127 @@ +// +// 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_USRP2_FW_COMMON_H +#define INCLUDED_USRP2_FW_COMMON_H + +/*! + * Structs and constants for usrp2 communication. + * This header is shared by the firmware and host code. + * Therefore, this header may only contain valid C code. + */ +#ifdef __cplusplus +extern "C" { +#endif + +// udp ports for the usrp2 communication +// Dynamic and/or private ports: 49152-65535 +#define USRP2_UDP_CTRL_PORT 49152 +#define USRP2_UDP_DATA_PORT 49153 + +typedef enum{ + USRP2_CTRL_ID_HUH_WHAT, + //USRP2_CTRL_ID_FOR_SURE, //TODO error condition enums + //USRP2_CTRL_ID_SUX_MAN, + + USRP2_CTRL_ID_GIVE_ME_YOUR_IP_ADDR_BRO, + USRP2_CTRL_ID_THIS_IS_MY_IP_ADDR_DUDE, + USRP2_CTRL_ID_HERE_IS_A_NEW_IP_ADDR_BRO, + + USRP2_CTRL_ID_GIVE_ME_YOUR_MAC_ADDR_BRO, + USRP2_CTRL_ID_THIS_IS_MY_MAC_ADDR_DUDE, + USRP2_CTRL_ID_HERE_IS_A_NEW_MAC_ADDR_BRO, + + USRP2_CTRL_ID_GIVE_ME_YOUR_DBOARD_IDS_BRO, + USRP2_CTRL_ID_THESE_ARE_MY_DBOARD_IDS_DUDE, + + USRP2_CTRL_ID_HERES_A_NEW_CLOCK_CONFIG_BRO, + USRP2_CTRL_ID_GOT_THE_NEW_CLOCK_CONFIG_DUDE, + + USRP2_CTRL_ID_USE_THESE_GPIO_DDR_SETTINGS_BRO, + USRP2_CTRL_ID_GOT_THE_GPIO_DDR_SETTINGS_DUDE, + + USRP2_CTRL_ID_SET_YOUR_GPIO_PIN_OUTS_BRO, + USRP2_CTRL_ID_I_SET_THE_GPIO_PIN_OUTS_DUDE, + + USRP2_CTRL_ID_GIVE_ME_YOUR_GPIO_PIN_VALS_BRO, + USRP2_CTRL_ID_HERE_IS_YOUR_GPIO_PIN_VALS_DUDE, + + USRP2_CTRL_ID_USE_THESE_ATR_SETTINGS_BRO, + USRP2_CTRL_ID_GOT_THE_ATR_SETTINGS_DUDE, + + USRP2_CTRL_ID_PEACE_OUT + +} usrp2_ctrl_id_t; + +typedef enum{ + USRP2_PPS_SOURCE_SMA, + USRP2_PPS_SOURCE_MIMO +} usrp2_pps_source_t; + +typedef enum{ + USRP2_PPS_POLARITY_POS, + USRP2_PPS_POLARITY_NEG +} usrp2_pps_polarity_t; + +typedef enum{ + USRP2_REF_SOURCE_INT, + USRP2_REF_SOURCE_SMA, + USRP2_REF_SOURCE_MIMO +} usrp2_ref_source_t; + +typedef enum{ + USRP2_GPIO_BANK_RX, + USRP2_GPIO_BANK_TX +} usrp2_gpio_bank_t; + +typedef struct{ + uint32_t id; + uint32_t seq; + union{ + uint32_t ip_addr; + uint8_t mac_addr[6]; + struct { + uint16_t rx_id; + uint16_t tx_id; + } dboard_ids; + struct { + uint8_t pps_source; + uint8_t pps_polarity; + uint8_t ref_source; + uint8_t _pad; + } clock_config; + struct { + uint8_t bank; + uint8_t _pad[3]; + uint16_t value; + uint16_t mask; + } gpio_config; + struct { + uint8_t bank; + uint8_t _pad[3]; + uint16_t tx_value; + uint16_t rx_value; + uint16_t mask; + } atr_config; + } data; +} usrp2_ctrl_data_t; + +#ifdef __cplusplus +} +#endif + +#endif /* INCLUDED_USRP2_FW_COMMON_H */ diff --git a/host/lib/usrp/mboard/usrp2/impl_base.cpp b/host/lib/usrp/mboard/usrp2/impl_base.cpp new file mode 100644 index 000000000..e81b7cdb0 --- /dev/null +++ b/host/lib/usrp/mboard/usrp2/impl_base.cpp @@ -0,0 +1,276 @@ +// +// 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 <boost/format.hpp> +#include <uhd/utils.hpp> +#include <uhd/props.hpp> +#include <iostream> +#include "impl_base.hpp" +#include "dboard_interface.hpp" + +using namespace uhd; +using namespace uhd::usrp; + +/*********************************************************************** + * Structors + **********************************************************************/ +impl_base::impl_base( + uhd::transport::udp::sptr ctrl_transport, + uhd::transport::udp::sptr data_transport +){ + _ctrl_transport = ctrl_transport; + _data_transport = data_transport; + + //grab the dboard ids over the control line + usrp2_ctrl_data_t out_data; + out_data.id = htonl(USRP2_CTRL_ID_GIVE_ME_YOUR_DBOARD_IDS_BRO); + usrp2_ctrl_data_t in_data = ctrl_send_and_recv(out_data); + ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_THESE_ARE_MY_DBOARD_IDS_DUDE); + std::cout << boost::format("rx id 0x%.2x, tx id 0x%.2x") + % ntohs(in_data.data.dboard_ids.rx_id) + % ntohs(in_data.data.dboard_ids.tx_id) << std::endl; + + //extract the dboard ids an convert them to enums + dboard::dboard_id_t rx_dboard_id = static_cast<dboard::dboard_id_t>( + ntohs(in_data.data.dboard_ids.rx_id) + ); + dboard::dboard_id_t tx_dboard_id = static_cast<dboard::dboard_id_t>( + ntohs(in_data.data.dboard_ids.tx_id) + ); + + //create a new dboard interface and manager + dboard::interface::sptr _dboard_interface( + new dboard_interface(this) + ); + dboard::manager::sptr dboard_manager( + new dboard::manager(rx_dboard_id, tx_dboard_id, _dboard_interface) + ); + + //load dboards + _rx_dboards[""] = dboard_impl::sptr(new dboard_impl(dboard_manager, dboard_impl::TYPE_RX)); + _tx_dboards[""] = dboard_impl::sptr(new dboard_impl(dboard_manager, dboard_impl::TYPE_TX)); + + //TOD load dsps + + //init the pps source clock config + _pps_source_dict["sma"] = USRP2_PPS_SOURCE_SMA; + _pps_source_dict["mimo"] = USRP2_PPS_SOURCE_MIMO; + _pps_source = "sma"; + + //init the pps polarity clock config + _pps_polarity_dict["pos"] = USRP2_PPS_POLARITY_POS; + _pps_polarity_dict["neg"] = USRP2_PPS_POLARITY_NEG; + _pps_polarity = "neg"; + + //init the ref source clock config + _ref_source_dict["int"] = USRP2_REF_SOURCE_INT; + _ref_source_dict["sma"] = USRP2_REF_SOURCE_SMA; + _ref_source_dict["mimo"] = USRP2_REF_SOURCE_MIMO; + _ref_source = "int"; + + //update the clock config (sends a control packet) + update_clock_config(); +} + +impl_base::~impl_base(void){ + /* NOP */ +} + +/*********************************************************************** + * Misc Access Methods + **********************************************************************/ +double impl_base::get_master_clock_freq(void){ + return 100e6; +} + +void impl_base::update_clock_config(void){ + //setup the out data + usrp2_ctrl_data_t out_data; + out_data.id = htonl(USRP2_CTRL_ID_HERES_A_NEW_CLOCK_CONFIG_BRO); + out_data.data.clock_config.pps_source = _pps_source_dict [_pps_source]; + out_data.data.clock_config.pps_polarity = _pps_polarity_dict[_pps_polarity]; + out_data.data.clock_config.ref_source = _ref_source_dict [_ref_source]; + + //send and recv + usrp2_ctrl_data_t in_data = ctrl_send_and_recv(out_data); + ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_GOT_THE_NEW_CLOCK_CONFIG_DUDE); +} + +/*********************************************************************** + * Control Send/Recv + **********************************************************************/ +usrp2_ctrl_data_t impl_base::ctrl_send_and_recv(const usrp2_ctrl_data_t &out_data){ + boost::mutex::scoped_lock lock(_ctrl_mutex); + + //fill in the seq number and send + usrp2_ctrl_data_t out_copy = out_data; + 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; + while(true){ + uhd::shared_iovec iov = _ctrl_transport->recv(); + if (iov.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; + } + //didnt get seq, continue on... + } + } + throw std::runtime_error("usrp2 no control response"); +} + +/*********************************************************************** + * Get Properties + **********************************************************************/ +void impl_base::get(const wax::obj &key_, wax::obj &val){ + wax::obj key; std::string name; + boost::tie(key, name) = extract_named_prop(key_); + + //handle the get request conditioned on the key + switch(wax::cast<mboard_prop_t>(key)){ + case MBOARD_PROP_NAME: + val = std::string("usrp2 mboard"); + return; + + case MBOARD_PROP_OTHERS: + val = prop_names_t(); //empty other props + return; + + case MBOARD_PROP_RX_DBOARD: + val = _rx_dboards[name]->get_link(); + return; + + case MBOARD_PROP_RX_DBOARD_NAMES: + val = prop_names_t(_rx_dboards.get_keys()); + return; + + case MBOARD_PROP_TX_DBOARD: + val = _tx_dboards[name]->get_link(); + return; + + case MBOARD_PROP_TX_DBOARD_NAMES: + 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: + throw std::runtime_error("unhandled prop in usrp2 mboard"); + + case MBOARD_PROP_RX_DSP_NAMES: + throw std::runtime_error("unhandled prop in usrp2 mboard"); + + case MBOARD_PROP_TX_DSP: + throw std::runtime_error("unhandled prop in usrp2 mboard"); + + case MBOARD_PROP_TX_DSP_NAMES: + throw std::runtime_error("unhandled prop in usrp2 mboard"); + + case MBOARD_PROP_PPS_SOURCE: + val = _pps_source; + return; + + case MBOARD_PROP_PPS_SOURCE_NAMES: + val = prop_names_t(_pps_source_dict.get_keys()); + return; + + case MBOARD_PROP_PPS_POLARITY: + val = _pps_polarity; + return; + + case MBOARD_PROP_REF_SOURCE: + val = _ref_source; + return; + + case MBOARD_PROP_REF_SOURCE_NAMES: + val = prop_names_t(_ref_source_dict.get_keys()); + return; + + case MBOARD_PROP_TIME_NOW: + case MBOARD_PROP_TIME_NEXT_PPS: + throw std::runtime_error("Error: trying to get write-only property on usrp2 mboard"); + + } +} + +/*********************************************************************** + * Set Properties + **********************************************************************/ +void impl_base::set(const wax::obj &key, const wax::obj &val){ + //handle the get request conditioned on the key + switch(wax::cast<mboard_prop_t>(key)){ + + case MBOARD_PROP_PPS_SOURCE:{ + std::string name = wax::cast<std::string>(val); + ASSERT_THROW(_pps_source_dict.has_key(name)); + _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)); + _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)); + _ref_source = name; //shadow + update_clock_config(); + } + 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: + case MBOARD_PROP_TX_DSP: + case MBOARD_PROP_TX_DSP_NAMES: + case MBOARD_PROP_RX_DBOARD: + case MBOARD_PROP_RX_DBOARD_NAMES: + case MBOARD_PROP_TX_DBOARD: + 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/mboard/usrp2/impl_base.hpp b/host/lib/usrp/mboard/usrp2/impl_base.hpp new file mode 100644 index 000000000..b808cf2b1 --- /dev/null +++ b/host/lib/usrp/mboard/usrp2/impl_base.hpp @@ -0,0 +1,78 @@ +// +// 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 <boost/utility.hpp> +#include <boost/thread.hpp> +#include <boost/shared_ptr.hpp> +#include <uhd/transport/udp.hpp> +#include <uhd/dict.hpp> +#include "dboard_impl.hpp" +#include "fw_common.h" + +#ifndef INCLUDED_IMPL_BASE_HPP +#define INCLUDED_IMPL_BASE_HPP + +class impl_base : boost::noncopyable, public wax::obj{ +public: + typedef boost::shared_ptr<impl_base> sptr; + + /*! + * Create a new usrp2 impl base. + * \param ctrl_transport the udp transport for control + * \param data_transport the udp transport for data + */ + impl_base( + uhd::transport::udp::sptr ctrl_transport, + uhd::transport::udp::sptr data_transport + ); + + ~impl_base(void); + + //performs a control transaction + usrp2_ctrl_data_t ctrl_send_and_recv(const usrp2_ctrl_data_t &); + + //properties access methods + void get(const wax::obj &, wax::obj &); + void set(const wax::obj &, const wax::obj &); + + //misc access methods + double get_master_clock_freq(void); + void update_clock_config(void); + +private: + //udp transports for control and data + uhd::transport::udp::sptr _ctrl_transport; + uhd::transport::udp::sptr _data_transport; + + //private vars for dealing with send/recv control + uint32_t _ctrl_seq_num; + boost::mutex _ctrl_mutex; + + //containers for the dboard objects + uhd::dict<std::string, dboard_impl::sptr> _rx_dboards; + uhd::dict<std::string, dboard_impl::sptr> _tx_dboards; + + //shadows for various settings + std::string _pps_source, _pps_polarity, _ref_source; + + //mappings from clock config strings to over the wire enums + uhd::dict<std::string, usrp2_pps_source_t> _pps_source_dict; + uhd::dict<std::string, usrp2_pps_polarity_t> _pps_polarity_dict; + uhd::dict<std::string, usrp2_ref_source_t> _ref_source_dict; +}; + +#endif /* INCLUDED_IMPL_BASE_HPP */ diff --git a/host/lib/usrp/usrp.cpp b/host/lib/usrp/usrp.cpp new file mode 100644 index 000000000..86a40ebd8 --- /dev/null +++ b/host/lib/usrp/usrp.cpp @@ -0,0 +1,98 @@ +// +// 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/usrp.hpp> +#include <uhd/usrp/mboard/usrp2.hpp> +#include <uhd/usrp/mboard/test.hpp> +#include <boost/format.hpp> +#include <boost/bind.hpp> +#include <stdexcept> + +using namespace uhd::usrp; + +/*********************************************************************** + * default callbacks for the send and recv + * these should be replaced with callbacks from the mboard object + **********************************************************************/ +static void send_raw_default(const std::vector<boost::asio::const_buffer> &){ + throw std::runtime_error("No callback registered for send raw"); +} + +static uhd::shared_iovec recv_raw_default(void){ + throw std::runtime_error("No callback registered for recv raw"); +} + +/*********************************************************************** + * the usrp device wrapper + **********************************************************************/ +usrp::usrp(const device_addr_t &device_addr){ + //set the default callbacks, the code below should replace them + _send_raw_cb = boost::bind(&send_raw_default, _1); + _recv_raw_cb = boost::bind(&recv_raw_default); + + //create mboard based on the device addr + if (not device_addr.has_key("type")){ + //TODO nothing + } + else if (device_addr["type"] == "test"){ + _mboards[""] = mboard::base::sptr(new mboard::test(device_addr)); + } + else if (device_addr["type"] == "udp"){ + _mboards[""] = mboard::base::sptr(new mboard::usrp2(device_addr)); + } +} + +usrp::~usrp(void){ + /* NOP */ +} + +void usrp::get(const wax::obj &key_, wax::obj &val){ + wax::obj key; std::string name; + boost::tie(key, name) = extract_named_prop(key_); + + //handle the get request conditioned on the key + switch(wax::cast<device_prop_t>(key)){ + case DEVICE_PROP_NAME: + val = std::string("usrp device"); + return; + + case DEVICE_PROP_MBOARD: + if (not _mboards.has_key(name)) throw std::invalid_argument( + str(boost::format("Unknown mboard name %s") % name) + ); + //turn the mboard sptr object into a wax::obj::sptr + //this allows the properties access through the wax::proxy + val = _mboards[name]->get_link(); + return; + + case DEVICE_PROP_MBOARD_NAMES: + val = prop_names_t(_mboards.get_keys()); + return; + } +} + +void usrp::set(const wax::obj &, const wax::obj &){ + throw std::runtime_error("Cannot set in usrp device"); +} + +void usrp::send_raw(const std::vector<boost::asio::const_buffer> &buffs){ + return _send_raw_cb(buffs); +} + +uhd::shared_iovec usrp::recv_raw(void){ + return _recv_raw_cb(); +} diff --git a/host/lib/wax.cpp b/host/lib/wax.cpp new file mode 100644 index 000000000..c08398c50 --- /dev/null +++ b/host/lib/wax.cpp @@ -0,0 +1,146 @@ +// +// 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/wax.hpp> +#include <boost/format.hpp> +#include <stdexcept> + +/*! + * The link args for internal use within this cpp file: + * + * It contains a link (in this case a pointer) to a wax object. + * Only the methods in this file may create or parse link args. + * The get_link method is the creator of a link args object. + * The [] operator will resolve the link and make the [] call. + * + * TODO: register the link args with the wax obj that it links to. + * That way, if the obj destructs, the link can be invalidated. + * The operator() will throw, rather than dereferencing bad memory. + */ +class link_args_t{ +public: + link_args_t(const wax::obj *obj_ptr) : _obj_ptr(obj_ptr){ + /* NOP */ + } + wax::obj & operator()(void){ + return *const_cast<wax::obj *>(_obj_ptr); + } +private: + const wax::obj *_obj_ptr; +}; + +/*! + * The proxy args for internal use within this cpp file: + * + * It contains a link and a key for setting/getting a property. + * Only the methods in this file may create or parse proxy args. + * Class methods have special handling for the case when the + * wax obj contains an instance of the proxy args. + */ +class proxy_args_t{ +public: + proxy_args_t(const wax::obj *obj_ptr, const wax::obj &key) : _key(key){ + _obj_link = obj_ptr->get_link(); + } + wax::obj & operator()(void){ + return wax::cast<link_args_t>(_obj_link)(); + } + const wax::obj & key(void){ + return _key; + } +private: + wax::obj _obj_link; + const wax::obj _key; +}; + +/*********************************************************************** + * Structors + **********************************************************************/ +wax::obj::obj(void){ + /* NOP */ +} + +wax::obj::obj(const obj &o){ + _contents = o._contents; +} + +wax::obj::~obj(void){ + /* NOP */ +} + +/*********************************************************************** + * Special Operators + **********************************************************************/ +wax::obj wax::obj::operator[](const obj &key){ + if (_contents.type() == typeid(proxy_args_t)){ + obj val = resolve(); + //check if its a special link and call + if (val.type() == typeid(link_args_t)){ + return cast<link_args_t>(val)()[key]; + } + //unknown obj + throw std::runtime_error("cannot use [] on non wax::obj link"); + } + else{ + return proxy_args_t(this, key); + } +} + +wax::obj & wax::obj::operator=(const obj &val){ + if (_contents.type() == typeid(proxy_args_t)){ + proxy_args_t proxy_args = boost::any_cast<proxy_args_t>(_contents); + proxy_args().set(proxy_args.key(), val); + } + else{ + _contents = val._contents; + } + return *this; +} + +/*********************************************************************** + * Public Methods + **********************************************************************/ +wax::obj wax::obj::get_link(void) const{ + return link_args_t(this); +} + +const std::type_info & wax::obj::type(void) const{ + return resolve().type(); +} + +/*********************************************************************** + * Private Methods + **********************************************************************/ +boost::any wax::obj::resolve(void) const{ + if (_contents.type() == typeid(proxy_args_t)){ + obj val; + proxy_args_t proxy_args = boost::any_cast<proxy_args_t>(_contents); + proxy_args().get(proxy_args.key(), val); + return val.resolve(); + } + else{ + return _contents; + } +} + +void wax::obj::get(const obj &, obj &){ + throw std::runtime_error("Cannot call get on wax obj base class"); +} + +void wax::obj::set(const obj &, const obj &){ + throw std::runtime_error("Cannot call set on wax obj base class"); +} |