diff options
Diffstat (limited to 'usrp_uhd/include')
| -rw-r--r-- | usrp_uhd/include/.gitignore | 2 | ||||
| -rw-r--r-- | usrp_uhd/include/Makefile.am | 14 | ||||
| -rw-r--r-- | usrp_uhd/include/usrp_uhd.hpp | 43 | ||||
| -rw-r--r-- | usrp_uhd/include/usrp_uhd/usrp_addr.hpp | 90 | ||||
| -rw-r--r-- | usrp_uhd/include/usrp_uhd/wax.hpp | 129 |
5 files changed, 278 insertions, 0 deletions
diff --git a/usrp_uhd/include/.gitignore b/usrp_uhd/include/.gitignore new file mode 100644 index 000000000..b336cc7ce --- /dev/null +++ b/usrp_uhd/include/.gitignore @@ -0,0 +1,2 @@ +/Makefile +/Makefile.in diff --git a/usrp_uhd/include/Makefile.am b/usrp_uhd/include/Makefile.am new file mode 100644 index 000000000..b5d09b431 --- /dev/null +++ b/usrp_uhd/include/Makefile.am @@ -0,0 +1,14 @@ +# +# Copyright 2010 Ettus Research LLC +# + +include $(top_srcdir)/Makefile.common + +SUBDIRS = + +usrp_uhd_includedir = $(includedir) + +usrp_uhd_include_HEADERS = \ + usrp_uhd.hpp \ + usrp_uhd/usrp_addr.hpp \ + usrp_uhd/wax.hpp diff --git a/usrp_uhd/include/usrp_uhd.hpp b/usrp_uhd/include/usrp_uhd.hpp new file mode 100644 index 000000000..6bf97a5a4 --- /dev/null +++ b/usrp_uhd/include/usrp_uhd.hpp @@ -0,0 +1,43 @@ +// +// Copyright 2010 Ettus Research LLC +// + +#ifndef INCLUDED_USRP_UHD_HPP +#define INCLUDED_USRP_UHD_HPP + +#include <usrp_uhd/usrp_addr.hpp> +#include <usrp_uhd/wax.hpp> +#include <boost/shared_ptr.hpp> +#include <boost/function.hpp> +#include <vector> +#include <sys/uio.h> + +namespace usrp{ + + class uhd{ + + public: + typedef boost::shared_ptr<uhd> sptr; + typedef boost::function<bool(void *data, size_t len)> recv_hdlr_t; + uhd(usrp_addr_t usrp_addr); + ~uhd(void); + + //the io interface + void send(const std::vector<iovec> &iovs); + void send(void* data, size_t len); //wrapper + void recv(const recv_hdlr_t &recv_hdlr); + void recv(void* &data, size_t &len); //wrapper + + //connect dsps and subdevs + void connect(const wax::type &src, const wax::type &sink); + + //the properties interface + wax::proxy props(void); + + private: + wax::type d_mboard; + }; + +} //namespace usrp + +#endif /* INCLUDED_USRP_UHD_HPP */ diff --git a/usrp_uhd/include/usrp_uhd/usrp_addr.hpp b/usrp_uhd/include/usrp_uhd/usrp_addr.hpp new file mode 100644 index 000000000..e8c282288 --- /dev/null +++ b/usrp_uhd/include/usrp_uhd/usrp_addr.hpp @@ -0,0 +1,90 @@ +// +// Copyright 2010 Ettus Research LLC +// + +#ifndef INCLUDED_USRP_ADDR_HPP +#define INCLUDED_USRP_ADDR_HPP + +#include <string> +#include <iostream> +#include <netinet/ether.h> +#include <arpa/inet.h> + +namespace usrp{ + + /*! + * Wrapper for an ethernet mac address. + * Provides conversion between string and binary formats. + */ + struct mac_addr_t{ + struct ether_addr d_mac_addr; + mac_addr_t(const std::string &str = "00:00:00:00:00:00"); + std::string to_string(void) const; + }; + + /*! + * Wrapper for an ipv4 address. + * Provides conversion between string and binary formats. + */ + struct ip_addr_t{ + struct in_addr d_ip_addr; + ip_addr_t(const std::string &str = "0.0.0.0"); + std::string to_string(void) const; + }; + + /*! + * Possible usrp mboard interface types. + */ + enum usrp_addr_type_t{ + USRP_ADDR_TYPE_AUTO, + USRP_ADDR_TYPE_VIRTUAL, + USRP_ADDR_TYPE_USB, + USRP_ADDR_TYPE_ETH, + USRP_ADDR_TYPE_UDP, + USRP_ADDR_TYPE_GPMC + }; + + /*! + * Structure to hold properties that identify a usrp mboard. + */ + struct usrp_addr_t{ + usrp_addr_type_t type; + struct{ + size_t num_rx_dsps; + size_t num_tx_dsps; + size_t num_dboards; + } virtual_args; + struct{ + uint16_t vendor_id; + uint16_t product_id; + } usb_args; + struct{ + std::string ifc; + mac_addr_t mac_addr; + } eth_args; + struct{ + ip_addr_t ip_addr; + } udp_args; + struct{ + //TODO unknown for now + } gpmc_args; + + /*! + * \brief Convert a usrp usrp_addr_t into a string representation + */ + std::string to_string(void) const; + + /*! + * \brief Default constructor to initialize the usrp_addr_t struct + */ + usrp_addr_t(usrp_addr_type_t usrp_addr_type = USRP_ADDR_TYPE_AUTO); + }; + +} //namespace usrp + +//ability to use types with stream operators +std::ostream& operator<<(std::ostream &os, const usrp::usrp_addr_t &x); +std::ostream& operator<<(std::ostream &os, const usrp::mac_addr_t &x); +std::ostream& operator<<(std::ostream &os, const usrp::ip_addr_t &x); + +#endif /* INCLUDED_USRP_ADDR_HPP */ diff --git a/usrp_uhd/include/usrp_uhd/wax.hpp b/usrp_uhd/include/usrp_uhd/wax.hpp new file mode 100644 index 000000000..9d32314f7 --- /dev/null +++ b/usrp_uhd/include/usrp_uhd/wax.hpp @@ -0,0 +1,129 @@ +// +// Copyright 2010 Ettus Research LLC +// + +#ifndef INCLUDED_WAX_HPP +#define INCLUDED_WAX_HPP + +#include <boost/any.hpp> +#include <boost/function.hpp> +#include <boost/shared_ptr.hpp> +#include <boost/weak_ptr.hpp> +#include <boost/pointer_cast.hpp> +#include <iostream> + +/*! + * WAX - it's a metaphor! + * + * The WAX framework allows object to have generic/anytype properties. + * These properties can be addressed through generic/anytype identifiers. + * A property of a WAX object may even be another WAX object. + * + * When a property is a WAX object, the returned value must be an obj pointer. + * A WAX object provides two types of pointers: obj::ptr and obj::sptr. + * The choice of pointer vs smart pointer depends on the owner of the memory. + * + * Proprties may be referenced though the [] overloaded operator. + * The [] operator returns a special proxy that allows for assigment. + * Also, the [] operators may be chained as in the folowing examples: + * my_obj[prop1][prop2][prop3] = value + * value = my_obj[prop1][prop2][prop3] + * + * Any value returned from an access operation is of wax::type. + * To use this value, it must be cast with wax::cast<new_type>(value). + */ + +namespace wax{ + + //general typedefs + typedef boost::any type; + typedef boost::bad_any_cast bad_cast; + + //dummy class declarations + class obj; class proxy; + + /*! + * WAX object base class: + * A wax object subclass should override the set and get methods. + * The magic of operator chaining is handled by the [] operator. + */ + class obj{ + public: + //obj pointer typedefs + typedef boost::shared_ptr<obj> sptr; + typedef obj* ptr; + + //cast derived pointer to obj base class pointer + template <class T> static sptr cast(boost::shared_ptr<T> r){ + return boost::static_pointer_cast<obj>(r); + } + template <class T> static ptr cast(T *r){ + return dynamic_cast<ptr>(r); + } + + //structors + obj(void); + virtual ~obj(void); + + //public interface + proxy operator[](const type &key); + + private: + //private interface + virtual void get(const type &key, type &val) = 0; + virtual void set(const type &key, const type &val) = 0; + }; + + /*! + * WAX proxy class: + * Allows the obj [] operator to return a proxy result. + * This result can be assigned to via the = operator. + * Or this result can be called again with the [] operator. + */ + class proxy{ + public: + //destructors + ~proxy(void); + + //overloaded + type operator()(void); + proxy operator[](const type &key); + proxy operator=(const type &key); + + private: + //typedefs for callables from the object that built this proxy + typedef boost::function<void(const type &)> setter_t; + typedef boost::function<void(type &)> getter_t; + + //private contructor + proxy(getter_t, setter_t); + //access to private contructor + friend proxy obj::operator[](const type &key); + + getter_t d_getter; + setter_t d_setter; + }; + + /*! + * Cast a wax::type into the desired type + * Usage wax::cast<new_type>(my_value). + * + * \param val the any type to cast + * \return data of the desired type + * \throw wax::bad_cast when the cast fails + */ + template<typename T> T cast(const type & val){ + //special case to handle the proxy + if (val.type() == typeid(proxy)){ + return cast<T>(boost::any_cast<proxy>(val)()); + } + //do the type cast + return boost::any_cast<T>(val); + } + +} //namespace wax + +//ability to use types with stream operators +std::ostream& operator<<(std::ostream &os, const wax::type &x); + +#endif /* INCLUDED_WAX_HPP */ |