aboutsummaryrefslogtreecommitdiffstats
path: root/host/lib
diff options
context:
space:
mode:
Diffstat (limited to 'host/lib')
-rw-r--r--host/lib/usrp/CMakeLists.txt13
-rw-r--r--host/lib/usrp/e300/CMakeLists.txt12
-rw-r--r--host/lib/usrp/e300/e300_async_serial.cpp245
-rw-r--r--host/lib/usrp/e300/e300_async_serial.hpp113
-rw-r--r--host/lib/usrp/e300/e300_impl.cpp70
-rw-r--r--host/lib/usrp/e300/e300_impl.hpp11
-rw-r--r--host/lib/usrp/e300/e300_network.cpp13
-rw-r--r--host/lib/usrp/e300/e300_sensor_manager.cpp141
-rw-r--r--host/lib/usrp/e300/e300_sensor_manager.hpp9
-rw-r--r--host/lib/usrp/e300/e300_ublox_control.hpp50
-rw-r--r--host/lib/usrp/e300/e300_ublox_control_impl.cpp505
-rw-r--r--host/lib/usrp/e300/e300_ublox_control_impl.hpp457
-rw-r--r--host/lib/usrp/gpsd_iface.cpp184
-rw-r--r--host/lib/usrp/gpsd_iface.hpp36
14 files changed, 319 insertions, 1540 deletions
diff --git a/host/lib/usrp/CMakeLists.txt b/host/lib/usrp/CMakeLists.txt
index f6788b5ef..ce913aaf6 100644
--- a/host/lib/usrp/CMakeLists.txt
+++ b/host/lib/usrp/CMakeLists.txt
@@ -18,6 +18,10 @@
########################################################################
# This file included, use CMake directory variables
########################################################################
+find_package(GPSD)
+
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
+
LIBUHD_APPEND_SOURCES(
${CMAKE_CURRENT_SOURCE_DIR}/dboard_base.cpp
${CMAKE_CURRENT_SOURCE_DIR}/dboard_eeprom.cpp
@@ -30,6 +34,15 @@ LIBUHD_APPEND_SOURCES(
${CMAKE_CURRENT_SOURCE_DIR}/subdev_spec.cpp
)
+LIBUHD_REGISTER_COMPONENT("GPSD" ENABLE_GPSD OFF "ENABLE_LIBUHD;ENABLE_GPSD;LIBGPS_FOUND" OFF)
+
+IF(ENABLE_GPSD)
+ LIBUHD_APPEND_SOURCES(
+ ${CMAKE_CURRENT_SOURCE_DIR}/gpsd_iface.cpp
+ )
+ LIBUHD_APPEND_LIBS(${LIBGPS_LIBRARY})
+ENDIF(ENABLE_GPSD)
+
INCLUDE_SUBDIRECTORY(cores)
INCLUDE_SUBDIRECTORY(dboard)
INCLUDE_SUBDIRECTORY(common)
diff --git a/host/lib/usrp/e300/CMakeLists.txt b/host/lib/usrp/e300/CMakeLists.txt
index 9ee9b5521..26e34294a 100644
--- a/host/lib/usrp/e300/CMakeLists.txt
+++ b/host/lib/usrp/e300/CMakeLists.txt
@@ -1,5 +1,5 @@
#
-# Copyright 2013-2014 Ettus Research LLC
+# Copyright 2013-2015 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
@@ -39,8 +39,6 @@ IF(ENABLE_E300)
${CMAKE_CURRENT_SOURCE_DIR}/e300_i2c.cpp
${CMAKE_CURRENT_SOURCE_DIR}/e300_eeprom_manager.cpp
${CMAKE_CURRENT_SOURCE_DIR}/e300_common.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/e300_async_serial.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/e300_ublox_control_impl.cpp
${CMAKE_CURRENT_SOURCE_DIR}/e300_remote_codec_ctrl.cpp
)
LIBUHD_APPEND_SOURCES(${E300_SOURCES})
@@ -52,4 +50,12 @@ IF(ENABLE_E300)
PROPERTIES COMPILE_DEFINITIONS "E300_NATIVE=1"
)
ENDIF(UDEV_FOUND)
+
+ IF(ENABLE_GPSD)
+ SET_SOURCE_FILES_PROPERTIES(
+ ${CMAKE_CURRENT_SOURCE_DIR}/e300_impl.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/e300_impl.hpp
+ PROPERTIES COMPILE_DEFINITIONS "E300_GPSD=1"
+ )
+ ENDIF(ENABLE_GPSD)
ENDIF(ENABLE_E300)
diff --git a/host/lib/usrp/e300/e300_async_serial.cpp b/host/lib/usrp/e300/e300_async_serial.cpp
deleted file mode 100644
index cdf18f7f7..000000000
--- a/host/lib/usrp/e300/e300_async_serial.cpp
+++ /dev/null
@@ -1,245 +0,0 @@
-//
-// Copyright 2014 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 "e300_async_serial.hpp"
-
-namespace uhd { namespace usrp { namespace gps {
-
-async_serial::async_serial()
- : _io(),
- _port(_io),
- _background_thread(),
- _open(false),
- _error(false)
-{
-}
-
-async_serial::async_serial(
- const std::string &node,
- const size_t baud_rate,
- boost::asio::serial_port_base::parity opt_parity,
- boost::asio::serial_port_base::character_size opt_csize,
- boost::asio::serial_port_base::flow_control opt_flow,
- boost::asio::serial_port_base::stop_bits opt_stop)
- : _io(),
- _port(_io),
- _background_thread(),
- _open(false),
- _error(false)
-{
- open(node, baud_rate, opt_parity, opt_csize, opt_flow, opt_stop);
-}
-
-void async_serial::open(
- const std::string &node,
- const size_t baud_rate,
- boost::asio::serial_port_base::parity opt_parity,
- boost::asio::serial_port_base::character_size opt_csize,
- boost::asio::serial_port_base::flow_control opt_flow,
- boost::asio::serial_port_base::stop_bits opt_stop)
-{
- if(is_open())
- close();
-
- _set_error_status(true);
- _port.open(node);
- _port.set_option(
- boost::asio::serial_port_base::baud_rate(baud_rate));
- _port.set_option(opt_parity);
- _port.set_option(opt_csize);
- _port.set_option(opt_flow);
- _port.set_option(opt_stop);
-
- _io.post(boost::bind(&async_serial::_do_read, this));
-
- boost::thread t(boost::bind(&boost::asio::io_service::run, &_io));
- _background_thread.swap(t);
- _set_error_status(false);
- _open=true;
-}
-
-bool async_serial::is_open() const
-{
- return _open;
-}
-
-bool async_serial::error_status() const
-{
- boost::lock_guard<boost::mutex> l(_error_mutex);
- return _error;
-}
-
-void async_serial::close()
-{
- if(!is_open())
- return;
-
- _open=false;
- _io.post(boost::bind(&async_serial::_do_close, this));
- _background_thread.join();
- _io.reset();
- if(error_status())
- throw(boost::system::system_error(boost::system::error_code(),
- "Error while closing the device"));
-}
-
-void async_serial::write(const char *data, size_t size)
-{
- {
- boost::lock_guard<boost::mutex> l(_write_queue_mutex);
- _write_queue.insert(_write_queue.end(), data, data+size);
- }
- _io.post(boost::bind(&async_serial::_do_write, this));
-}
-
-void async_serial::write(const std::vector<char> &data)
-{
- {
- boost::lock_guard<boost::mutex> l(_write_queue_mutex);
- _write_queue.insert(
- _write_queue.end(),
- data.begin(),
- data.end());
- }
- _io.post(boost::bind(&async_serial::_do_write, this));
-}
-
-void async_serial::write_string(const std::string &s)
-{
- {
- boost::lock_guard<boost::mutex> l(_write_queue_mutex);
- _write_queue.insert(
- _write_queue.end(),
- s.begin(),
- s.end());
- }
- _io.post(boost::bind(&async_serial::_do_write, this));
-}
-
-async_serial::~async_serial()
-{
- if(is_open()) {
- try {
- close();
- } catch(...) {
- //Don't throw from a destructor
- }
- }
-}
-
-void async_serial::_do_read()
-{
- _port.async_read_some(boost::asio::buffer(
- _read_buffer,READ_BUFFER_SIZE),
- boost::bind(&async_serial::_read_end,
- this,
- boost::asio::placeholders::error,
- boost::asio::placeholders::bytes_transferred));
-}
-
-void async_serial::_read_end(
- const boost::system::error_code& error,
- size_t bytes_transferred)
-{
- if(error) {
- if(is_open()) {
- _do_close();
- _set_error_status(true);
- }
- } else {
- if(_callback)
- _callback(
- _read_buffer,
- bytes_transferred);
- _do_read();
- }
-}
-
-void async_serial::_do_write()
-{
- // if a write operation is already in progress, do nothing
- if(_write_buffer == 0) {
- boost::lock_guard<boost::mutex> l(_write_queue_mutex);
- _write_buffer_size=_write_queue.size();
- _write_buffer.reset(new char[_write_queue.size()]);
- std::copy(_write_queue.begin(),_write_queue.end(),
- _write_buffer.get());
- _write_queue.clear();
- async_write(
- _port, boost::asio::buffer(_write_buffer.get(),
- _write_buffer_size),
- boost::bind(
- &async_serial::_write_end,
- this,
- boost::asio::placeholders::error));
- }
-}
-
-void async_serial::_write_end(const boost::system::error_code& error)
-{
- if(!error) {
- boost::lock_guard<boost::mutex> l(_write_queue_mutex);
- if(_write_queue.empty()) {
- _write_buffer.reset();
- _write_buffer_size=0;
- return;
- }
- _write_buffer_size = _write_queue.size();
- _write_buffer.reset(new char[_write_queue.size()]);
- std::copy(_write_queue.begin(),_write_queue.end(),
- _write_buffer.get());
- _write_queue.clear();
- async_write(
- _port,
- boost::asio::buffer(_write_buffer.get(),
- _write_buffer_size),
- boost::bind(
- &async_serial::_write_end,
- this,
- boost::asio::placeholders::error));
- } else {
- _set_error_status(true);
- _do_close();
- }
-}
-
-void async_serial::_do_close()
-{
- boost::system::error_code ec;
- _port.cancel(ec);
- if(ec)
- _set_error_status(true);
- _port.close(ec);
- if(ec)
- _set_error_status(true);
-}
-
-void async_serial::_set_error_status(const bool e)
-{
- boost::lock_guard<boost::mutex> l(_error_mutex);
- _error = e;
-}
-
-
-void async_serial::set_read_callback(
- const boost::function<void (const char*, size_t)> &callback)
-{
- _callback = callback;
-}
-
-
-}}} // namespace
diff --git a/host/lib/usrp/e300/e300_async_serial.hpp b/host/lib/usrp/e300/e300_async_serial.hpp
deleted file mode 100644
index fafc7de3d..000000000
--- a/host/lib/usrp/e300/e300_async_serial.hpp
+++ /dev/null
@@ -1,113 +0,0 @@
-//
-// Copyright 2013-2014 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_ASYNC_SERIAL_HPP
-#define INCLUDED_ASYNC_SERIAL_HPP
-
-#include <boost/asio.hpp>
-#include <boost/bind.hpp>
-#include <boost/thread.hpp>
-#include <boost/utility.hpp>
-#include <boost/function.hpp>
-#include <boost/shared_array.hpp>
-
-namespace uhd { namespace usrp { namespace gps {
-
-class async_serial : private boost::noncopyable
-{
-public:
- async_serial();
- ~async_serial();
-
- async_serial(const std::string &node, const size_t baud_rate,
- boost::asio::serial_port_base::parity opt_parity=
- boost::asio::serial_port_base::parity(
- boost::asio::serial_port_base::parity::none),
- boost::asio::serial_port_base::character_size opt_csize=
- boost::asio::serial_port_base::character_size(8),
- boost::asio::serial_port_base::flow_control opt_flow=
- boost::asio::serial_port_base::flow_control(
- boost::asio::serial_port_base::flow_control::none),
- boost::asio::serial_port_base::stop_bits opt_stop=
- boost::asio::serial_port_base::stop_bits(
- boost::asio::serial_port_base::stop_bits::one));
-
- void open(const std::string& node, const size_t baud_rate,
- boost::asio::serial_port_base::parity opt_parity=
- boost::asio::serial_port_base::parity(
- boost::asio::serial_port_base::parity::none),
- boost::asio::serial_port_base::character_size opt_csize=
- boost::asio::serial_port_base::character_size(8),
- boost::asio::serial_port_base::flow_control opt_flow=
- boost::asio::serial_port_base::flow_control(
- boost::asio::serial_port_base::flow_control::none),
- boost::asio::serial_port_base::stop_bits opt_stop=
- boost::asio::serial_port_base::stop_bits(
- boost::asio::serial_port_base::stop_bits::one));
-
- bool is_open(void) const;
-
- bool error_status(void) const;
-
- void close(void);
-
- void write(const char *data, const size_t size);
- void write(const std::vector<char> &data);
-
- void write_string(const std::string &s);
-
- static const size_t READ_BUFFER_SIZE=512;
-
- void set_read_callback(
- const boost::function<void (const char*, size_t)>& callback);
-
- void clear_callback();
-
-private: // methods
- void _do_read();
-
- void _read_end(
- const boost::system::error_code &error,
- size_t bytes_transferred);
-
- void _do_write();
-
- void _write_end(const boost::system::error_code &error);
-
- void _do_close();
-
- void _set_error_status(const bool e);
-private: // members
- boost::asio::io_service _io;
- boost::asio::serial_port _port;
- boost::thread _background_thread;
- bool _open;
- bool _error;
- mutable boost::mutex _error_mutex;
-
- std::vector<char> _write_queue;
- boost::shared_array<char> _write_buffer;
- size_t _write_buffer_size;
- boost::mutex _write_queue_mutex;
- char _read_buffer[READ_BUFFER_SIZE];
-
- boost::function<void (const char*, size_t)> _callback;
-};
-
-}}} // namespace
-
-#endif //INCLUDED_ASYNC_SERIAL_HPP
diff --git a/host/lib/usrp/e300/e300_impl.cpp b/host/lib/usrp/e300/e300_impl.cpp
index 9a695b57e..ee4ee5ca4 100644
--- a/host/lib/usrp/e300/e300_impl.cpp
+++ b/host/lib/usrp/e300/e300_impl.cpp
@@ -394,19 +394,35 @@ e300_impl::e300_impl(const uhd::device_addr_t &device_addr)
// This is horrible ... why do I have to sleep here?
boost::this_thread::sleep(boost::posix_time::milliseconds(100));
_eeprom_manager = boost::make_shared<e300_eeprom_manager>(i2c::make_i2cdev(E300_I2CDEV_DEVICE));
+ _sensor_manager = e300_sensor_manager::make_local(_global_regs);
}
_codec_mgr = ad936x_manager::make(_codec_ctrl, fpga::NUM_RADIOS);
- UHD_MSG(status) << "Detecting internal GPSDO.... " << std::flush;
- if (_xport_path == AXI) {
- try {
- _gps = gps::ublox::ubx::control::make("/dev/ttyPS1", 9600);
- } catch (std::exception &e) {
- UHD_MSG(error) << "An error occured making GPSDO control: " << e.what() << std::endl;
+#ifdef E300_GPSD
+ UHD_MSG(status) << "Detecting internal GPSDO " << std::flush;
+ try {
+ if (_xport_path == AXI)
+ _gps = gpsd_iface::make("localhost", 2947);
+ else
+ _gps = gpsd_iface::make(device_addr["addr"], 2947);
+ } catch (std::exception &e) {
+ UHD_MSG(error) << "An error occured making GPSDd interface: " << e.what() << std::endl;
+ }
+
+ if (_gps) {
+ for (size_t i = 0; i < _GPS_TIMEOUT; i++)
+ {
+ boost::this_thread::sleep(boost::posix_time::seconds(1));
+ if (!_gps->gps_detected())
+ std::cout << "." << std::flush;
+ else {
+ std::cout << ".... " << std::flush;
+ break;
+ }
}
- _sensor_manager = e300_sensor_manager::make_local(_gps, _global_regs);
+ UHD_MSG(status) << (_gps->gps_detected() ? "found" : "not found") << std::endl;
}
- UHD_MSG(status) << (_sensor_manager->get_gps_found() ? "found" : "not found") << std::endl;
+#endif
// Verify we can talk to the e300 core control registers ...
UHD_MSG(status) << "Initializing core control..." << std::endl;
@@ -451,6 +467,15 @@ e300_impl::e300_impl(const uhd::device_addr_t &device_addr)
_tree->create<sensor_value_t>(mb_path / "sensors" / name)
.publish(boost::bind(&e300_sensor_manager::get_sensor, _sensor_manager, name));
}
+#ifdef E300_GPSD
+ if (_gps) {
+ BOOST_FOREACH(const std::string &name, _gps->get_sensors())
+ {
+ _tree->create<sensor_value_t>(mb_path / "sensors" / name)
+ .publish(boost::bind(&gpsd_iface::get_sensor, _gps, name));
+ }
+ }
+#endif
////////////////////////////////////////////////////////////////////
// setup the mboard eeprom
@@ -513,7 +538,11 @@ e300_impl::e300_impl(const uhd::device_addr_t &device_addr)
_tree->create<std::string>(mb_path / "time_source" / "value")
.subscribe(boost::bind(&e300_impl::_update_time_source, this, _1))
.set(e300::DEFAULT_TIME_SRC);
+#ifdef E300_GPSD
static const std::vector<std::string> time_sources = boost::assign::list_of("none")("internal")("external")("gpsdo");
+#else
+ static const std::vector<std::string> time_sources = boost::assign::list_of("none")("internal")("external");
+#endif
_tree->create<std::vector<std::string> >(mb_path / "time_source" / "options").set(time_sources);
//setup reference source props
_tree->create<std::string>(mb_path / "clock_source" / "value")
@@ -593,12 +622,25 @@ e300_impl::e300_impl(const uhd::device_addr_t &device_addr)
_tree->access<subdev_spec_t>(mb_path / "rx_subdev_spec").set(rx_spec);
_tree->access<subdev_spec_t>(mb_path / "tx_subdev_spec").set(tx_spec);
- UHD_MSG(status) << "Initializing time to the internal GPSDO" << std::endl;
- const time_t tp = time_t(_sensor_manager->get_sensor("gps_time").to_int()+1);
- _tree->access<time_spec_t>(mb_path / "time" / "pps").set(time_spec_t(tp));
+#ifdef E300_GPSD
+ //GPS installed: use external ref, time, and init time spec
+ if (_gps and _gps->gps_detected()) {
+ UHD_MSG(status) << "Setting references to the internal GPSDO"
+ << std::endl;
+ _tree->access<std::string>(mb_path / "time_source" / "value").set("gpsdo");
+ UHD_MSG(status) << "Initializing time to the internal GPSDO"
+ << std::endl;
+ const time_t tp = time_t(_gps->get_sensor("gps_time").to_int()+1);
+ _tree->access<time_spec_t>(mb_path / "time" / "pps").set(time_spec_t(tp));
+
+ // wait for time to be actually set
+ boost::this_thread::sleep(boost::posix_time::seconds(1));
+ }
+#else
+ //init to internal clock and time source
+ _tree->access<std::string>(mb_path / "time_source/value").set("internal");
+#endif// E300_GPSD
- // wait for time to be actually set
- boost::this_thread::sleep(boost::posix_time::seconds(1));
}
boost::uint8_t e300_impl::_get_internal_gpio(gpio_core_200::sptr gpio)
@@ -792,8 +834,10 @@ void e300_impl::_update_time_source(const std::string &source)
UHD_MSG(status) << boost::format("Setting time source to %s") % source << std::endl;
if (source == "none" or source == "internal") {
_misc.pps_sel = global_regs::PPS_INT;
+#ifdef E300_GPSD
} else if (source == "gpsdo") {
_misc.pps_sel = global_regs::PPS_GPS;
+#endif
} else if (source == "external") {
_misc.pps_sel = global_regs::PPS_EXT;
} else {
diff --git a/host/lib/usrp/e300/e300_impl.hpp b/host/lib/usrp/e300/e300_impl.hpp
index d61b95387..8aff51466 100644
--- a/host/lib/usrp/e300/e300_impl.hpp
+++ b/host/lib/usrp/e300/e300_impl.hpp
@@ -47,7 +47,11 @@
#include "e300_i2c.hpp"
#include "e300_eeprom_manager.hpp"
#include "e300_sensor_manager.hpp"
-#include "e300_ublox_control.hpp"
+
+/* if we don't compile with gpsd support, don't bother */
+#ifdef E300_GPSD
+#include "gpsd_iface.hpp"
+#endif
namespace uhd { namespace usrp { namespace e300 {
@@ -299,7 +303,10 @@ private: // members
std::string _idle_image;
bool _do_not_reload;
gpio_t _misc;
- gps::ublox::ubx::control::sptr _gps;
+#ifdef E300_GPSD
+ gpsd_iface::sptr _gps;
+ static const size_t _GPS_TIMEOUT = 5;
+#endif
};
}}} // namespace
diff --git a/host/lib/usrp/e300/e300_network.cpp b/host/lib/usrp/e300/e300_network.cpp
index d68dc4541..96387d6f7 100644
--- a/host/lib/usrp/e300/e300_network.cpp
+++ b/host/lib/usrp/e300/e300_network.cpp
@@ -349,19 +349,9 @@ static void e300_sensor_tunnel(
// TODO: This is ugly ... use proper serialization
in->value = uhd::htonx<boost::uint32_t>(
e300_sensor_manager::pack_float_in_uint32_t(temp.to_real()));
- } else if (uhd::ntohx(in->which) == GPS_FOUND) {
- in->value = uhd::htonx<boost::uint32_t>(
- sensor_manager->get_gps_found() ? 1 : 0);
-
- } else if (uhd::ntohx(in->which) == GPS_LOCK) {
- in->value = uhd::htonx<boost::uint32_t>(
- sensor_manager->get_gps_lock().to_bool() ? 1 : 0);
} else if (uhd::ntohx(in->which) == REF_LOCK) {
in->value = uhd::htonx<boost::uint32_t>(
sensor_manager->get_ref_lock().to_bool() ? 1 : 0);
- } else if (uhd::ntohx(in->which) == GPS_TIME) {
- in->value = uhd::htonx<boost::uint32_t>(
- sensor_manager->get_gps_time().to_int());
} else
UHD_MSG(status) << "Got unknown request?!" << std::endl;
@@ -648,8 +638,7 @@ network_server_impl::network_server_impl(const uhd::device_addr_t &device_addr)
_codec_ctrl = ad9361_ctrl::make_spi(client_settings, spi::make(E300_SPIDEV_DEVICE), 1);
// This is horrible ... why do I have to sleep here?
boost::this_thread::sleep(boost::posix_time::milliseconds(100));
- _sensor_manager = e300_sensor_manager::make_local(
- gps::ublox::ubx::control::make("/dev/ttyPS1", 9600), _global_regs);
+ _sensor_manager = e300_sensor_manager::make_local(_global_regs);
}
}}} // namespace
diff --git a/host/lib/usrp/e300/e300_sensor_manager.cpp b/host/lib/usrp/e300/e300_sensor_manager.cpp
index 527cfb91a..a4319fa4b 100644
--- a/host/lib/usrp/e300/e300_sensor_manager.cpp
+++ b/host/lib/usrp/e300/e300_sensor_manager.cpp
@@ -24,7 +24,6 @@
#include <cstring>
#include <uhd/exception.hpp>
#include <uhd/utils/byteswap.hpp>
-#include <uhd/usrp/gps_ctrl.hpp>
namespace uhd { namespace usrp { namespace e300 {
@@ -38,17 +37,13 @@ public:
std::vector<std::string> get_sensors()
{
- return boost::assign::list_of("temp")("gps_locked")("gps_time")("ref_locked");
+ return boost::assign::list_of("temp")("ref_locked");
}
uhd::sensor_value_t get_sensor(const std::string &key)
{
if (key == "temp")
return get_mb_temp();
- else if (key == "gps_locked")
- return get_gps_lock();
- else if (key == "gps_time")
- return get_gps_time();
else if (key == "ref_locked")
return get_ref_lock();
else
@@ -94,108 +89,6 @@ public:
"C");
}
- uhd::sensor_value_t get_gps_time(void)
- {
- boost::mutex::scoped_lock(_mutex);
- sensor_transaction_t transaction;
- transaction.which = uhd::htonx<boost::uint32_t>(GPS_TIME);
- {
- uhd::transport::managed_send_buffer::sptr buff
- = _xport->get_send_buff(1.0);
- if (not buff or buff->size() < sizeof(transaction)) {
- throw uhd::runtime_error("sensor proxy send timeout");
- }
- std::memcpy(
- buff->cast<void *>(),
- &transaction,
- sizeof(transaction));
- buff->commit(sizeof(transaction));
- }
- {
- uhd::transport::managed_recv_buffer::sptr buff
- = _xport->get_recv_buff(1.0);
-
- if (not buff or buff->size() < sizeof(transaction))
- throw uhd::runtime_error("sensor proxy recv timeout");
-
- std::memcpy(
- &transaction,
- buff->cast<const void *>(),
- sizeof(transaction));
- }
- UHD_ASSERT_THROW(uhd::ntohx<boost::uint32_t>(transaction.which) == GPS_TIME);
- // TODO: Use proper serialization here ...
- return sensor_value_t("GPS epoch time", int(uhd::ntohx<boost::uint32_t>(transaction.value)), "seconds");
- }
-
- bool get_gps_found(void)
- {
- boost::mutex::scoped_lock(_mutex);
- sensor_transaction_t transaction;
- transaction.which = uhd::htonx<boost::uint32_t>(GPS_FOUND);
- {
- uhd::transport::managed_send_buffer::sptr buff
- = _xport->get_send_buff(1.0);
- if (not buff or buff->size() < sizeof(transaction)) {
- throw uhd::runtime_error("sensor proxy send timeout");
- }
- std::memcpy(
- buff->cast<void *>(),
- &transaction,
- sizeof(transaction));
- buff->commit(sizeof(transaction));
- }
- {
- uhd::transport::managed_recv_buffer::sptr buff
- = _xport->get_recv_buff(1.0);
-
- if (not buff or buff->size() < sizeof(transaction))
- throw uhd::runtime_error("sensor proxy recv timeout");
-
- std::memcpy(
- &transaction,
- buff->cast<const void *>(),
- sizeof(transaction));
- }
- UHD_ASSERT_THROW(uhd::ntohx<boost::uint32_t>(transaction.which) == GPS_FOUND);
- // TODO: Use proper serialization here ...
- return (uhd::ntohx(transaction.value) > 0);
- }
-
- uhd::sensor_value_t get_gps_lock(void)
- {
- boost::mutex::scoped_lock(_mutex);
- sensor_transaction_t transaction;
- transaction.which = uhd::htonx<boost::uint32_t>(GPS_LOCK);
- {
- uhd::transport::managed_send_buffer::sptr buff
- = _xport->get_send_buff(1.0);
- if (not buff or buff->size() < sizeof(transaction)) {
- throw uhd::runtime_error("sensor proxy send timeout");
- }
- std::memcpy(
- buff->cast<void *>(),
- &transaction,
- sizeof(transaction));
- buff->commit(sizeof(transaction));
- }
- {
- uhd::transport::managed_recv_buffer::sptr buff
- = _xport->get_recv_buff(1.0);
-
- if (not buff or buff->size() < sizeof(transaction))
- throw uhd::runtime_error("sensor proxy recv timeout");
-
- std::memcpy(
- &transaction,
- buff->cast<const void *>(),
- sizeof(transaction));
- }
- UHD_ASSERT_THROW(uhd::ntohx<boost::uint32_t>(transaction.which) == GPS_LOCK);
- // TODO: Use proper serialization here ...
- return sensor_value_t("GPS lock status", (uhd::ntohx(transaction.value) > 0), "locked", "unlocked");
- }
-
uhd::sensor_value_t get_ref_lock(void)
{
boost::mutex::scoped_lock(_mutex);
@@ -255,24 +148,20 @@ static const std::string E300_TEMP_SYSFS = "iio:device0";
class e300_sensor_local : public e300_sensor_manager
{
public:
- e300_sensor_local(uhd::gps_ctrl::sptr gps_ctrl, global_regs::sptr global_regs) :
- _gps_ctrl(gps_ctrl), _global_regs(global_regs)
+ e300_sensor_local(global_regs::sptr global_regs) :
+ _global_regs(global_regs)
{
}
std::vector<std::string> get_sensors()
{
- return boost::assign::list_of("temp")("gps_locked")("gps_time")("ref_locked");
+ return boost::assign::list_of("temp")("ref_locked");
}
uhd::sensor_value_t get_sensor(const std::string &key)
{
if (key == "temp")
return get_mb_temp();
- else if (key == "gps_locked")
- return get_gps_lock();
- else if (key == "gps_time")
- return get_gps_time();
else if (key == "ref_locked")
return get_ref_lock();
else
@@ -291,21 +180,6 @@ public:
return sensor_value_t("temp", (raw + offset) * scale / 1000, "C");
}
- bool get_gps_found(void)
- {
- return _gps_ctrl->gps_detected();
- }
-
- uhd::sensor_value_t get_gps_lock(void)
- {
- return _gps_ctrl->get_sensor("gps_locked");
- }
-
- uhd::sensor_value_t get_gps_time(void)
- {
- return _gps_ctrl->get_sensor("gps_time");
- }
-
uhd::sensor_value_t get_ref_lock(void)
{
//PPSLOOP_LOCKED_MASK is asserted in the following cases:
@@ -322,22 +196,21 @@ public:
}
private:
- gps_ctrl::sptr _gps_ctrl;
global_regs::sptr _global_regs;
};
}}}
using namespace uhd::usrp::e300;
e300_sensor_manager::sptr e300_sensor_manager::make_local(
- uhd::gps_ctrl::sptr gps_ctrl, global_regs::sptr global_regs)
+ global_regs::sptr global_regs)
{
- return sptr(new e300_sensor_local(gps_ctrl, global_regs));
+ return sptr(new e300_sensor_local(global_regs));
}
#else
using namespace uhd::usrp::e300;
e300_sensor_manager::sptr e300_sensor_manager::make_local(
- uhd::gps_ctrl::sptr, global_regs::sptr)
+ global_regs::sptr)
{
throw uhd::assertion_error("e300_sensor_manager::make_local() !E300_NATIVE");
}
diff --git a/host/lib/usrp/e300/e300_sensor_manager.hpp b/host/lib/usrp/e300/e300_sensor_manager.hpp
index 09f889251..bfaf8e90c 100644
--- a/host/lib/usrp/e300/e300_sensor_manager.hpp
+++ b/host/lib/usrp/e300/e300_sensor_manager.hpp
@@ -39,25 +39,22 @@ struct sensor_transaction_t {
-enum sensor {ZYNQ_TEMP=0, GPS_FOUND=1, GPS_TIME=2,
- GPS_LOCK=3, REF_LOCK=4};
+enum sensor {ZYNQ_TEMP=0, REF_LOCK=4};
class e300_sensor_manager : boost::noncopyable
{
public:
typedef boost::shared_ptr<e300_sensor_manager> sptr;
- virtual bool get_gps_found(void) = 0;
virtual uhd::sensor_value_t get_sensor(const std::string &key) = 0;
virtual std::vector<std::string> get_sensors(void) = 0;
virtual uhd::sensor_value_t get_mb_temp(void) = 0;
- virtual uhd::sensor_value_t get_gps_lock(void) = 0;
- virtual uhd::sensor_value_t get_gps_time(void) = 0;
virtual uhd::sensor_value_t get_ref_lock(void) = 0;
+
static sptr make_proxy(uhd::transport::zero_copy_if::sptr xport);
- static sptr make_local(uhd::gps_ctrl::sptr gps_ctrl, global_regs::sptr global_regs);
+ static sptr make_local(global_regs::sptr global_regs);
// Note: This is a hack
static boost::uint32_t pack_float_in_uint32_t(const float &v)
diff --git a/host/lib/usrp/e300/e300_ublox_control.hpp b/host/lib/usrp/e300/e300_ublox_control.hpp
deleted file mode 100644
index 8705d6c52..000000000
--- a/host/lib/usrp/e300/e300_ublox_control.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#ifndef INCLUDED_UHD_USRP_UBLOX_CONTROL_HPP
-#define INCLUDED_UHD_USRP_UBLOX_CONTROL_HPP
-
-#include <boost/cstdint.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/asio.hpp>
-#include <uhd/config.hpp>
-#include <uhd/usrp/gps_ctrl.hpp>
-#include <uhd/types/sensors.hpp>
-
-#include "e300_async_serial.hpp"
-
-namespace uhd { namespace usrp { namespace gps {
-
-namespace ublox { namespace ubx {
-
-class control : public virtual uhd::gps_ctrl
-{
-public:
- typedef boost::shared_ptr<control> sptr;
-
- static sptr make(const std::string &node, const size_t baud_rate);
-
- virtual void configure_message_rate(
- const boost::uint16_t msg,
- const boost::uint8_t rate) = 0;
-
- virtual void configure_antenna(
- const boost::uint16_t flags,
- const boost::uint16_t pins) = 0;
-
- virtual void configure_pps(
- const boost::uint32_t interval,
- const boost::uint32_t length,
- const boost::int8_t status,
- const boost::uint8_t time_ref,
- const boost::uint8_t flags,
- const boost::int16_t antenna_delay,
- const boost::int16_t rf_group_delay,
- const boost::int32_t user_delay) = 0;
-
- virtual void configure_rates(
- boost::uint16_t meas_rate,
- boost::uint16_t nav_rate,
- boost::uint16_t time_ref) = 0;
-};
-}} // namespace ublox::ubx
-
-}}} // namespace
-#endif // INCLUDED_UHD_USRP_UBLOX_CONTROL_HPP
diff --git a/host/lib/usrp/e300/e300_ublox_control_impl.cpp b/host/lib/usrp/e300/e300_ublox_control_impl.cpp
deleted file mode 100644
index 389bf79fa..000000000
--- a/host/lib/usrp/e300/e300_ublox_control_impl.cpp
+++ /dev/null
@@ -1,505 +0,0 @@
-#include <boost/format.hpp>
-#include <boost/foreach.hpp>
-#include <boost/bind.hpp>
-#include <boost/make_shared.hpp>
-#include <boost/lexical_cast.hpp>
-#include <boost/assign/list_of.hpp>
-#include "boost/date_time/posix_time/posix_time.hpp"
-
-#include <iostream>
-
-
-#include <uhd/utils/byteswap.hpp>
-#include <uhd/utils/msg.hpp>
-#include <uhd/exception.hpp>
-
-#include "e300_ublox_control.hpp"
-
-#ifdef E300_NATIVE
-#include "e300_ublox_control_impl.hpp"
-
-
-namespace uhd { namespace usrp { namespace gps {
-
-namespace ublox { namespace ubx {
-
-control_impl::control_impl(const std::string &node, const size_t baud_rate)
-{
- _decode_init();
- _serial = boost::make_shared<async_serial>(node, baud_rate);
- _serial->set_read_callback(boost::bind(&control_impl::_rx_callback, this, _1, _2));
-
- _detect();
-
- configure_message_rate(MSG_GLL, 0);
- configure_message_rate(MSG_GSV, 0);
- configure_message_rate(MSG_GGA, 0);
- configure_message_rate(MSG_GSA, 0);
- configure_message_rate(MSG_RMC, 0);
- configure_message_rate(MSG_VTG, 0);
- configure_message_rate(MSG_NAV_TIMEUTC, 1);
- configure_message_rate(MSG_NAV_SOL, 1);
-
- configure_antenna(0x001b, 0x8251);
-
- configure_pps(0xf4240, 0x3d090, 1, 0 /* utc */, 1, 0, 0, 0);
-
- _sensors = boost::assign::list_of("gps_locked")("gps_time");
-}
-
-bool control_impl::gps_detected(void)
-{
- return _detected;
-}
-
-void control_impl::_detect(void)
-{
- _send_message(MSG_MON_VER, NULL, 0);
-}
-
-std::vector<std::string> control_impl::get_sensors(void)
-{
- return _sensors;
-}
-
-uhd::sensor_value_t control_impl::get_sensor(std::string key)
-{
- if (key == "gps_time") {
- bool lock;
- _locked.wait_and_see(lock);
- return sensor_value_t("GPS epoch time",
- lock ? int(_get_epoch_time()) : 0, "seconds");
- } else if (key == "gps_locked") {
- bool lock;
- _locked.wait_and_see(lock);
- return sensor_value_t("GPS lock status", lock, "locked", "unlocked");
- } else
- throw uhd::key_error(str(boost::format("sensor %s unknown.") % key));
-}
-
-std::time_t control_impl::_get_epoch_time(void)
-{
- boost::posix_time::ptime ptime;
- _ptime.wait_and_see(ptime);
- return (ptime - boost::posix_time::from_time_t(0)).total_seconds();
-}
-
-control_impl::~control_impl(void)
-{
-}
-
-void control_impl::_decode_init(void)
-{
- _decode_state = DECODE_SYNC1;
- _rx_ck_a = 0;
- _rx_ck_b = 0;
- _rx_payload_length = 0;
- _rx_payload_index = 0;
-}
-
-void control_impl::_add_byte_to_checksum(const boost::uint8_t b)
-{
- _rx_ck_a = _rx_ck_a + b;
- _rx_ck_b = _rx_ck_b + _rx_ck_a;
-}
-
-void control_impl::_calc_checksum(
- const boost::uint8_t *buffer,
- const boost::uint16_t length,
- checksum_t &checksum)
-{
- for (size_t i = 0; i < length; i++)
- {
- checksum.ck_a = checksum.ck_a + buffer[i];
- checksum.ck_b = checksum.ck_b + checksum.ck_a;
- }
-}
-
-void control_impl::configure_rates(
- boost::uint16_t meas_rate,
- boost::uint16_t nav_rate,
- boost::uint16_t time_ref)
-{
- payload_tx_cfg_rate_t cfg_rate;
- cfg_rate.meas_rate = uhd::htowx<boost::uint16_t>(meas_rate);
- cfg_rate.nav_rate = uhd::htowx<boost::uint16_t>(nav_rate);
- cfg_rate.time_ref = uhd::htowx<boost::uint16_t>(time_ref);
-
- _send_message(
- MSG_CFG_RATE,
- reinterpret_cast<const uint8_t*>(&cfg_rate),
- sizeof(cfg_rate));
-
- _wait_for_ack(MSG_CFG_RATE, 1.0);
-}
-
-void control_impl::configure_message_rate(
- const boost::uint16_t msg,
- const uint8_t rate)
-{
- payload_tx_cfg_msg_t cfg_msg;
- cfg_msg.msg = uhd::htowx<boost::uint16_t>(msg);
- cfg_msg.rate[0] = 0;//rate;
- cfg_msg.rate[1] = rate;
- cfg_msg.rate[2] = 0;//rate;
- cfg_msg.rate[3] = 0;//rate;
- cfg_msg.rate[4] = 0;//rate;
- cfg_msg.rate[5] = 0;//rate;
- _send_message(
- MSG_CFG_MSG,
- reinterpret_cast<const uint8_t*>(&cfg_msg),
- sizeof(cfg_msg));
-
- _wait_for_ack(MSG_CFG_MSG, 1.0);
-}
-
-void control_impl::configure_antenna(
- const boost::uint16_t flags,
- const boost::uint16_t pins)
-{
- payload_tx_cfg_ant_t cfg_ant;
- cfg_ant.pins = uhd::htowx<boost::uint16_t>(pins);
- cfg_ant.flags = uhd::htowx<boost::uint16_t>(flags);
- _send_message(
- MSG_CFG_ANT,
- reinterpret_cast<const uint8_t*>(&cfg_ant),
- sizeof(cfg_ant));
- if (_wait_for_ack(MSG_CFG_ANT, 1.0) < 0) {
- throw uhd::runtime_error("Didn't get an ACK for antenna configuration.");
- }
-
-}
-
-void control_impl::configure_pps(
- const boost::uint32_t interval,
- const boost::uint32_t length,
- const boost::int8_t status,
- const boost::uint8_t time_ref,
- const boost::uint8_t flags,
- const boost::int16_t antenna_delay,
- const boost::int16_t rf_group_delay,
- const boost::int32_t user_delay)
-{
- payload_tx_cfg_tp_t cfg_tp;
- cfg_tp.interval = uhd::htowx<boost::uint32_t>(interval);
- cfg_tp.length = uhd::htowx<boost::uint32_t>(length);
- cfg_tp.status = status;
- cfg_tp.time_ref = time_ref;
- cfg_tp.flags = flags;
- cfg_tp.antenna_delay = uhd::htowx<boost::int16_t>(antenna_delay);
- cfg_tp.rf_group_delay = uhd::htowx<boost::int16_t>(rf_group_delay);
- cfg_tp.user_delay = uhd::htowx<boost::int32_t>(user_delay);
- _send_message(
- MSG_CFG_TP,
- reinterpret_cast<const uint8_t*>(&cfg_tp),
- sizeof(cfg_tp));
- if (_wait_for_ack(MSG_CFG_TP, 1.0) < 0) {
- throw uhd::runtime_error("Didn't get an ACK for PPS configuration.");
- }
-}
-
-
-void control_impl::_rx_callback(const char *data, unsigned int len)
-{
- //std::cout << "IN RX CALLBACK" << std::flush << std::endl;
- std::vector<char> v(data, data+len);
- BOOST_FOREACH(const char &c, v)
- {
- _parse_char(c);
- }
-}
-
-void control_impl::_parse_char(const boost::uint8_t b)
-{
- int ret = 0;
-
- switch (_decode_state) {
-
- // we're expecting the first sync byte
- case DECODE_SYNC1:
- if (b == SYNC1) { // sync1 found goto next step
- _decode_state = DECODE_SYNC2;
- } // else stay around
- break;
-
- // we're expecting the second sync byte
- case DECODE_SYNC2:
- if (b == SYNC2) { // sync2 found goto next step
- _decode_state = DECODE_CLASS;
- } else {
- // failed, reset
- _decode_init();
- }
- break;
-
- // we're expecting the class byte
- case DECODE_CLASS:
- _add_byte_to_checksum(b);
- _rx_msg = b;
- _decode_state = DECODE_ID;
- break;
-
- // we're expecting the id byte
- case DECODE_ID:
- _add_byte_to_checksum(b);
- _rx_msg |= (b << 8);
- _decode_state = DECODE_LENGTH1;
- break;
-
- // we're expecting the first length byte
- case DECODE_LENGTH1:
- _add_byte_to_checksum(b);
- _rx_payload_length = b;
- _decode_state = DECODE_LENGTH2;
- break;
-
- // we're expecting the second length byte
- case DECODE_LENGTH2:
- _add_byte_to_checksum(b);
- _rx_payload_length |= (b << 8);
- if(_payload_rx_init()) {
- _decode_init(); // we failed, give up for this one
- } else {
- _decode_state = _rx_payload_length ?
- DECODE_PAYLOAD : DECODE_CHKSUM1;
- }
- break;
-
- // we're expecting payload
- case DECODE_PAYLOAD:
- _add_byte_to_checksum(b);
- switch(_rx_msg) {
- default:
- ret = _payload_rx_add(b);
- break;
- };
- if (ret < 0) {
- // we couldn't deal with the payload, discard the whole thing
- _decode_init();
- } else if (ret > 0) {
- // payload was complete, let's check the checksum;
- _decode_state = DECODE_CHKSUM1;
- } else {
- // more payload expected, don't move
- }
- ret = 0;
- break;
-
- case DECODE_CHKSUM1:
- if (_rx_ck_a != b) {
- // checksum didn't match, barf
- std::cout << boost::format("Failed checksum byte1 %lx != %lx")
- % int(_rx_ck_a) % int(b) << std::endl;
- _decode_init();
- } else {
- _decode_state = DECODE_CHKSUM2;
- }
- break;
-
- case DECODE_CHKSUM2:
- if (_rx_ck_b != b) {
- // checksum didn't match, barf
- std::cout << boost::format("Failed checksum byte2 %lx != %lx")
- % int(_rx_ck_b) % int(b) << std::endl;
-
- } else {
- ret = _payload_rx_done(); // payload done
- }
- _decode_init();
- break;
-
- default:
- break;
- };
-}
-
-int control_impl::_payload_rx_init(void)
-{
- int ret = 0;
-
- _rx_state = RXMSG_HANDLE; // by default handle
- switch(_rx_msg) {
-
- case MSG_NAV_SOL:
- if (not (_rx_payload_length == sizeof(payload_rx_nav_sol_t)))
- _rx_state = RXMSG_ERROR_LENGTH;
- break;
-
- case MSG_NAV_TIMEUTC:
- if (not (_rx_payload_length == sizeof(payload_rx_nav_timeutc_t)))
- _rx_state = RXMSG_ERROR_LENGTH;
- break;
-
- case MSG_MON_VER:
- break; // always take this one
-
- case MSG_ACK_ACK:
- if (not (_rx_payload_length == sizeof(payload_rx_ack_ack_t)))
- _rx_state = RXMSG_ERROR_LENGTH;
- break;
-
- case MSG_ACK_NAK:
- if (not (_rx_payload_length == sizeof(payload_rx_ack_nak_t)))
- _rx_state = RXMSG_ERROR_LENGTH;
- break;
-
- default:
- _rx_state = RXMSG_DISABLE;
- break;
- };
-
- switch (_rx_state) {
- case RXMSG_HANDLE: // handle message
- case RXMSG_IGNORE: // ignore message but don't report error
- ret = 0;
- break;
- case RXMSG_DISABLE: // ignore message but don't report error
- case RXMSG_ERROR_LENGTH: // the length doesn't match
- ret = -1;
- break;
- default: // invalid, error
- ret = -1;
- break;
- };
-
- return ret;
-}
-
-int control_impl::_payload_rx_add(const boost::uint8_t b)
-{
- int ret = 0;
- _buf.raw[_rx_payload_index] = b;
- if (++_rx_payload_index >= _rx_payload_length)
- ret = 1;
- return ret;
-}
-
-int control_impl::_payload_rx_done(void)
-{
- int ret = 0;
- if (_rx_state != RXMSG_HANDLE) {
- return 0;
- }
-
- switch (_rx_msg) {
- case MSG_MON_VER:
- _detected = true;
- break;
-
- case MSG_MON_HW:
- std::cout << "MON-HW" << std::endl;
- break;
-
- case MSG_ACK_ACK:
- if ((_ack_state == ACK_WAITING) and (_buf.payload_rx_ack_ack.msg == _ack_waiting_msg))
- _ack_state = ACK_GOT_ACK;
- break;
-
- case MSG_ACK_NAK:
- if ((_ack_state == ACK_WAITING) and (_buf.payload_rx_ack_nak.msg == _ack_waiting_msg))
- _ack_state = ACK_GOT_NAK;
-
- break;
-
- case MSG_CFG_ANT:
- break;
-
- case MSG_NAV_TIMEUTC:
- _ptime.update(boost::posix_time::ptime(
- boost::gregorian::date(
- boost::gregorian::greg_year(uhd::wtohx<boost::uint16_t>(
- _buf.payload_rx_nav_timeutc.year)),
- boost::gregorian::greg_month(_buf.payload_rx_nav_timeutc.month),
- boost::gregorian::greg_day(_buf.payload_rx_nav_timeutc.day)),
- (boost::posix_time::hours(_buf.payload_rx_nav_timeutc.hour)
- + boost::posix_time::minutes(_buf.payload_rx_nav_timeutc.min)
- + boost::posix_time::seconds(_buf.payload_rx_nav_timeutc.sec))));
- break;
-
- case MSG_NAV_SOL:
- _locked.update(_buf.payload_rx_nav_sol.gps_fix > 0);
- break;
-
- default:
- std::cout << boost::format("Got unknown message %lx , with good checksum [") % int(_rx_msg);
- for(size_t i = 0; i < _rx_payload_length; i++)
- std::cout << boost::format("%lx, ") % int(_buf.raw[i]);
- std::cout << "]"<< std::endl;
- break;
- };
- return ret;
-}
-
-void control_impl::_send_message(
- const boost::uint16_t msg,
- const boost::uint8_t *payload,
- const boost::uint16_t len)
-{
- header_t header = {SYNC1, SYNC2, msg, len};
- checksum_t checksum = {0, 0};
-
- // calculate checksums, first header without sync
- // then payload
- _calc_checksum(
- reinterpret_cast<boost::uint8_t*>(&header) + 2,
- sizeof(header) - 2, checksum);
- if (payload)
- _calc_checksum(payload, len, checksum);
-
- _serial->write(
- reinterpret_cast<const char*>(&header),
- sizeof(header));
-
- if (payload)
- _serial->write((const char *) payload, len);
-
- _serial->write(
- reinterpret_cast<const char*>(&checksum),
- sizeof(checksum));
-}
-
-int control_impl::_wait_for_ack(
- const boost::uint16_t msg,
- const double timeout)
-{
- int ret = -1;
-
- _ack_state = ACK_WAITING;
- _ack_waiting_msg = msg;
-
- boost::system_time timeout_time =
- boost::get_system_time() +
- boost::posix_time::milliseconds(timeout * 1000.0);
-
- do {
- if(_ack_state == ACK_GOT_ACK)
- return 0;
- else if (_ack_state == ACK_GOT_NAK) {
- return -1;
- }
- boost::this_thread::sleep(boost::posix_time::milliseconds(20));
- } while (boost::get_system_time() < timeout_time);
-
- // we get here ... it's a timeout
- _ack_state = ACK_IDLE;
- return ret;
-}
-
-
-}} // namespace ublox::ubx
-}}} // namespace
-
-using namespace uhd::usrp::gps::ublox::ubx;
-
-control::sptr control::make(const std::string &node, const size_t baud_rate)
-{
- return control::sptr(new control_impl(node, baud_rate));
-}
-#else
-using namespace uhd::usrp::gps::ublox::ubx;
-
-control::sptr control::make(const std::string& /* node */, const size_t /* baud_rate */)
-{
- throw uhd::assertion_error("control::sptr::make: !E300_NATIVE");
-}
-#endif // E300_NATIVE
diff --git a/host/lib/usrp/e300/e300_ublox_control_impl.hpp b/host/lib/usrp/e300/e300_ublox_control_impl.hpp
deleted file mode 100644
index a1dcbfe6c..000000000
--- a/host/lib/usrp/e300/e300_ublox_control_impl.hpp
+++ /dev/null
@@ -1,457 +0,0 @@
-#ifndef INCLUDED_UHD_USRP_UBLOX_CONTROL_IMPL_HPP
-#define INCLUDED_UHD_USRP_UBLOX_CONTROL_IMPL_HPP
-
-#include <boost/cstdint.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/asio.hpp>
-#include <uhd/config.hpp>
-#include <uhd/usrp/gps_ctrl.hpp>
-#include <uhd/types/sensors.hpp>
-
-#include "e300_async_serial.hpp"
-
-namespace uhd { namespace usrp { namespace gps {
-
-namespace ublox { namespace ubx {
-// ublox binary sync words
-static const boost::uint8_t SYNC1 = 0xB5;
-static const boost::uint8_t SYNC2 = 0x62;
-
-// message classes
-static const boost::uint8_t CLASS_NAV = 0x01;
-static const boost::uint8_t CLASS_ACK = 0x05;
-static const boost::uint8_t CLASS_CFG = 0x06;
-static const boost::uint8_t CLASS_MON = 0x0a;
-static const boost::uint8_t CLASS_NMEA = 0xf0;
-
-// Message IDs
-static const boost::uint8_t ID_NAV_POSLLH = 0x02;
-static const boost::uint8_t ID_NAV_SOL = 0x06;
-static const boost::uint8_t ID_NAV_PVT = 0x07;
-static const boost::uint8_t ID_NAV_VELNED = 0x12;
-static const boost::uint8_t ID_NAV_TIMEUTC = 0x21;
-static const boost::uint8_t ID_NAV_SVINFO = 0x30;
-static const boost::uint8_t ID_ACK_NAK = 0x00;
-static const boost::uint8_t ID_ACK_ACK = 0x01;
-static const boost::uint8_t ID_CFG_PRT = 0x00;
-static const boost::uint8_t ID_CFG_ANT = 0x13;
-static const boost::uint8_t ID_CFG_TP = 0x07;
-static const boost::uint8_t ID_CFG_MSG = 0x01;
-static const boost::uint8_t ID_CFG_RATE = 0x08;
-static const boost::uint8_t ID_CFG_NAV5 = 0x24;
-static const boost::uint8_t ID_MON_VER = 0x04;
-static const boost::uint8_t ID_MON_HW = 0x09;
-static const boost::uint8_t ID_GGA = 0x00;
-static const boost::uint8_t ID_GLL = 0x01;
-static const boost::uint8_t ID_GSA = 0x02;
-static const boost::uint8_t ID_GSV = 0x03;
-static const boost::uint8_t ID_RMC = 0x04;
-static const boost::uint8_t ID_VTG = 0x05;
-static const boost::uint8_t ID_GST = 0x07;
-
-// Message Classes & IDs //
-static const boost::uint16_t MSG_NAV_POSLLH
- = CLASS_NAV | (ID_NAV_POSLLH << 8);
-static const boost::uint16_t MSG_NAV_SOL
- = CLASS_NAV | (ID_NAV_SOL << 8);
-static const boost::uint16_t MSG_NAV_PVT
- = CLASS_NAV | (ID_NAV_PVT << 8);
-static const boost::uint16_t MSG_NAV_VELNED
- = CLASS_NAV | (ID_NAV_VELNED << 8);
-static const boost::uint16_t MSG_NAV_TIMEUTC
- = CLASS_NAV | (ID_NAV_TIMEUTC << 8);
-static const boost::uint16_t MSG_NAV_SVINFO
- = CLASS_NAV | (ID_NAV_SVINFO << 8);
-static const boost::uint16_t MSG_ACK_NAK
- = CLASS_ACK | (ID_ACK_NAK << 8);
-static const boost::uint16_t MSG_ACK_ACK
- = CLASS_ACK | (ID_ACK_ACK << 8);
-static const boost::uint16_t MSG_CFG_PRT
- = CLASS_CFG | (ID_CFG_PRT << 8);
-static const boost::uint16_t MSG_CFG_ANT
- = CLASS_CFG | (ID_CFG_ANT << 8);
-static const boost::uint16_t MSG_CFG_TP
- = CLASS_CFG | (ID_CFG_TP << 8);
-static const boost::uint16_t MSG_CFG_MSG
- = CLASS_CFG | (ID_CFG_MSG << 8);
-static const boost::uint16_t MSG_CFG_RATE
- = CLASS_CFG | (ID_CFG_RATE << 8);
-static const boost::uint16_t MSG_CFG_NAV5
- = CLASS_CFG | (ID_CFG_NAV5 << 8);
-static const boost::uint16_t MSG_MON_HW
- = CLASS_MON | (ID_MON_HW << 8);
-static const boost::uint16_t MSG_MON_VER
- = CLASS_MON | (ID_MON_VER << 8);
-
-// NMEA ones
-static const boost::uint16_t MSG_GGA
- = CLASS_NMEA | (ID_GGA << 8);
-static const boost::uint16_t MSG_GLL
- = CLASS_NMEA | (ID_GLL << 8);
-static const boost::uint16_t MSG_GSA
- = CLASS_NMEA | (ID_GSA << 8);
-static const boost::uint16_t MSG_GSV
- = CLASS_NMEA | (ID_GSV << 8);
-static const boost::uint16_t MSG_RMC
- = CLASS_NMEA | (ID_RMC << 8);
-static const boost::uint16_t MSG_VTG
- = CLASS_NMEA | (ID_VTG << 8);
-
-// header
-struct header_t
-{
- boost::uint8_t sync1;
- boost::uint8_t sync2;
- boost::uint16_t msg;
- boost::uint16_t length;
-};
-
-// checksum
-struct checksum_t
-{
- boost::uint8_t ck_a;
- boost::uint8_t ck_b;
-};
-
-// rx rx mon-hw (ubx6)
-struct payload_rx_mon_hw_t
-{
- boost::uint32_t pin_sel;
- boost::uint32_t pin_bank;
- boost::uint32_t pin_dir;
- boost::uint32_t pin_val;
- boost::uint16_t noise_per_ms;
- boost::uint16_t agc_cnt;
- boost::uint8_t a_status;
- boost::uint8_t a_power;
- boost::uint8_t flags;
- boost::uint8_t reserved1;
- boost::uint32_t used_mask;
- boost::uint8_t vp[25];
- boost::uint8_t jam_ind;
- boost::uint16_t reserved3;
- boost::uint32_t pin_irq;
- boost::uint32_t pullh;
- boost::uint32_t pulll;
-};
-
-// rx mon-ver
-struct payload_rx_mon_ver_part1_t
-{
- char sw_version[30];
- char hw_version[10];
-};
-
-struct payload_rx_mon_ver_part2_t
-{
- boost::uint8_t extension[30];
-};
-
-// rx ack-ack
-typedef union {
- boost::uint16_t msg;
- struct {
- boost::uint8_t cls_id;
- boost::uint8_t msg_id;
- };
-} payload_rx_ack_ack_t;
-
-// rx ack-nak
-typedef union {
- boost::uint16_t msg;
- struct {
- boost::uint8_t cls_id;
- boost::uint8_t msg_id;
- };
-} payload_rx_ack_nak_t;
-
-// tx cfg-prt (uart)
-struct payload_tx_cfg_prt_t
-{
- boost::uint8_t port_id;
- boost::uint8_t reserved0;
- boost::uint16_t tx_ready;
- boost::uint32_t mode;
- boost::uint32_t baud_rate;
- boost::uint16_t in_proto_mask;
- boost::uint16_t out_proto_mask;
- boost::uint16_t flags;
- boost::uint16_t reserved5;
-};
-
-// tx cfg-rate
-struct payload_tx_cfg_rate_t
-{
- boost::uint16_t meas_rate;
- boost::uint16_t nav_rate;
- boost::uint16_t time_ref;
-};
-
-// tx cfg-msg
-struct payload_tx_cfg_msg_t
-{
- boost::uint16_t msg;
- boost::uint8_t rate[6];
-};
-
-
-// tx cfg-ant
-struct payload_tx_cfg_ant_t
-{
- boost::uint16_t flags;
- boost::uint16_t pins;
-};
-
-// tx cfg-tp
-struct payload_tx_cfg_tp_t
-{
- boost::uint32_t interval;
- boost::uint32_t length;
- boost::int8_t status;
- boost::uint8_t time_ref;
- boost::uint8_t flags;
- boost::uint8_t reserved1;
- boost::int16_t antenna_delay;
- boost::int16_t rf_group_delay;
- boost::int32_t user_delay;
-};
-
-struct payload_rx_nav_sol_t
-{
- boost::uint32_t i_tow;
- boost::int32_t f_tow;
- boost::int16_t week;
- boost::uint8_t gps_fix;
- boost::uint8_t flags;
- boost::int32_t ecef_x;
- boost::int32_t ecef_y;
- boost::int32_t ecef_z;
- boost::uint32_t p_acc;
- boost::int32_t ecef_vx;
- boost::int32_t ecef_vy;
- boost::int32_t ecef_vz;
- boost::uint32_t s_acc;
- boost::uint16_t p_dop;
- boost::uint8_t reserved1;
- boost::uint8_t num_sv;
- boost::uint32_t reserved2;
-};
-
-struct payload_rx_nav_timeutc_t
-{
- boost::uint32_t i_tow;
- boost::uint32_t t_acc;
- boost::int32_t nano;
- boost::uint16_t year;
- boost::uint8_t month;
- boost::uint8_t day;
- boost::uint8_t hour;
- boost::uint8_t min;
- boost::uint8_t sec;
- boost::uint8_t valid;
-};
-
-typedef union {
- payload_rx_mon_hw_t payload_rx_mon_hw;
-
- payload_rx_mon_ver_part1_t payload_rx_mon_ver_part1;
- payload_rx_mon_ver_part2_t payload_rx_mon_ver_part2;
-
- payload_rx_ack_ack_t payload_rx_ack_ack;
- payload_rx_ack_nak_t payload_rx_ack_nak;
-
- payload_tx_cfg_prt_t payload_tx_cfg_prt;
- payload_tx_cfg_ant_t payload_tx_cfg_ant;
- payload_tx_cfg_rate_t payload_tx_cfg_rate;
-
- payload_tx_cfg_msg_t payload_tx_cfg_msg;
-
- payload_rx_nav_timeutc_t payload_rx_nav_timeutc;
- payload_rx_nav_sol_t payload_rx_nav_sol;
- boost::uint8_t raw[];
-} buf_t;
-
-
-template <typename T>
-class sensor_entry
-{
-public:
- sensor_entry() : _seen(false)
- {
- }
-
- void update(const T &val)
- {
- boost::mutex::scoped_lock l(_mutex);
- _value = val;
- _seen = false;
- l.unlock();
- _cond.notify_one();
- }
-
- bool seen() const
- {
- boost::mutex::scoped_lock l(_mutex);
- return _seen;
- }
-
- bool try_and_see(T &val)
- {
- boost::mutex::scoped_lock l(_mutex);
- if (_seen)
- return false;
-
- val = _value;
- _seen = true;
- return true;
- }
-
- void wait_and_see(T &val)
- {
- boost::mutex::scoped_lock l(_mutex);
- while(_seen)
- {
- _cond.wait(l);
- //std::cout << "Already seen ... " << std::endl;
- }
- val = _value;
- _seen = true;
- }
-
-private: // members
- T _value;
- boost::mutex _mutex;
- boost::condition_variable _cond;
- bool _seen;
-};
-
-class control_impl : public control
-{
-public:
- control_impl(const std::string &node, const size_t baud_rate);
-
- virtual ~control_impl(void);
-
- void configure_message_rate(
- const boost::uint16_t msg,
- const boost::uint8_t rate);
-
- void configure_antenna(
- const boost::uint16_t flags,
- const boost::uint16_t pins);
-
- void configure_pps(
- const boost::uint32_t interval,
- const boost::uint32_t length,
- const boost::int8_t status,
- const boost::uint8_t time_ref,
- const boost::uint8_t flags,
- const boost::int16_t antenna_delay,
- const boost::int16_t rf_group_delay,
- const boost::int32_t user_delay);
-
- void configure_rates(
- boost::uint16_t meas_rate,
- boost::uint16_t nav_rate,
- boost::uint16_t time_ref);
-
- // gps_ctrl interface
- bool gps_detected(void);
- std::vector<std::string> get_sensors(void);
- uhd::sensor_value_t get_sensor(std::string key);
-
-private: // types
- enum decoder_state_t {
- DECODE_SYNC1 = 0,
- DECODE_SYNC2,
- DECODE_CLASS,
- DECODE_ID,
- DECODE_LENGTH1,
- DECODE_LENGTH2,
- DECODE_PAYLOAD,
- DECODE_CHKSUM1,
- DECODE_CHKSUM2,
- };
-
- enum rxmsg_state_t {
- RXMSG_IGNORE = 0,
- RXMSG_HANDLE,
- RXMSG_DISABLE,
- RXMSG_ERROR_LENGTH
- };
-
- enum ack_state_t {
- ACK_IDLE = 0,
- ACK_WAITING,
- ACK_GOT_ACK,
- ACK_GOT_NAK
- };
-
-private: // methods
- std::time_t _get_epoch_time(void);
-
- void _decode_init(void);
-
- void _add_byte_to_checksum(const boost::uint8_t b);
-
- void _detect(void);
-
- void _send_message(
- const boost::uint16_t msg,
- const boost::uint8_t *payload,
- const boost::uint16_t len);
-
- int _wait_for_ack(
- const boost::uint16_t msg,
- const double timeout);
-
- void _calc_checksum(
- const boost::uint8_t *buffer,
- const boost::uint16_t length,
- checksum_t &checksum);
-
- void _rx_callback(const char *data, unsigned len);
-
- void _parse_char(const boost::uint8_t b);
-
- int _payload_rx_init(void);
-
- int _payload_rx_add(const boost::uint8_t b);
-
- int _payload_rx_done(void);
-
-private: // members
- // gps_ctrl stuff
- bool _detected;
- std::vector<std::string> _sensors;
-
- sensor_entry<bool> _locked;
- sensor_entry<boost::posix_time::ptime> _ptime;
-
- // decoder state
- decoder_state_t _decode_state;
- rxmsg_state_t _rxmsg_state;
-
- ack_state_t _ack_state;
- boost::uint16_t _ack_waiting_msg;
-
- boost::uint8_t _rx_ck_a;
- boost::uint8_t _rx_ck_b;
-
- boost::uint16_t _rx_payload_length;
- size_t _rx_payload_index;
- boost::uint16_t _rx_msg;
-
- rxmsg_state_t _rx_state;
-
- boost::shared_ptr<async_serial> _serial;
-
- // this has to be at the end of the
- // class to be valid C++
- buf_t _buf;
-};
-
-}} // namespace ublox::ubx
-
-}}} // namespace
-#endif // INCLUDED_UHD_USRP_UBLOX_CONTROL_IMPL_HPP
diff --git a/host/lib/usrp/gpsd_iface.cpp b/host/lib/usrp/gpsd_iface.cpp
new file mode 100644
index 000000000..62b6939c5
--- /dev/null
+++ b/host/lib/usrp/gpsd_iface.cpp
@@ -0,0 +1,184 @@
+//
+// Copyright 2015 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 <cmath>
+
+#include <gps.h>
+
+#include <boost/assign/list_of.hpp>
+#include <boost/bind.hpp>
+#include <boost/cstdint.hpp>
+#include "boost/date_time/gregorian/gregorian.hpp"
+#include <boost/format.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/thread/shared_mutex.hpp>
+#include <boost/thread.hpp>
+
+#include <uhd/exception.hpp>
+#include <uhd/usrp/gps_ctrl.hpp>
+#include <uhd/utils/msg.hpp>
+#include <uhd/types/dict.hpp>
+
+#include "gpsd_iface.hpp"
+
+namespace uhd { namespace usrp {
+
+static const size_t TIMEOUT = 240;
+static const size_t CLICK_RATE = 250000;
+
+class gpsd_iface_impl : public virtual gpsd_iface {
+public:
+ gpsd_iface_impl(const std::string &addr, boost::uint16_t port)
+ : _detected(false), _bthread(), _timeout_cnt(0)
+ {
+ boost::unique_lock<boost::shared_mutex> l(_d_mutex);
+
+ if (gps_open(addr.c_str(),
+ str(boost::format("%u") % port).c_str(),
+ &_gps_data) < 0) {
+ throw uhd::runtime_error(
+ str((boost::format("Failed to connect to gpsd: %s")
+ % gps_errstr(errno))));
+ }
+
+ // register for updates, we don't specify a specific device,
+ // therefore no WATCH_DEVICE
+ gps_stream(&_gps_data, WATCH_ENABLE, NULL);
+
+ // create background thread talking to gpsd
+ boost::thread t(boost::bind(&gpsd_iface_impl::_thread_fcn ,this));
+ _bthread.swap(t);
+
+
+ _sensors = boost::assign::list_of("gps_locked")("gps_time")("gps_position");
+ }
+
+ virtual ~gpsd_iface_impl(void)
+ {
+ // interrupt the background thread and wait for it to finish
+ _bthread.interrupt();
+ _bthread.join();
+
+ // clean up ...
+ {
+ boost::unique_lock<boost::shared_mutex> l(_d_mutex);
+
+ gps_stream(&_gps_data, WATCH_DISABLE, NULL);
+ gps_close(&_gps_data);
+ }
+ }
+
+ uhd::sensor_value_t get_sensor(std::string key)
+ {
+ if (key == "gps_locked") {
+ return sensor_value_t(
+ "GPS lock status", _gps_locked(), "locked", "unlocked");
+ } else if (key == "gps_time") {
+ return sensor_value_t(
+ "GPS epoch time", int(_epoch_time()), "seconds");
+ } else if (key == "gps_position") {
+ return sensor_value_t(
+ "GPS Position", str(
+ boost::format("%s %s %s")
+ % _gps_position()["lat"]
+ % _gps_position()["lon"]
+ % _gps_position()["alt"]), "lat/lon/alt");
+ } else
+ throw uhd::key_error(
+ str(boost::format("sensor %s unknown.") % key));
+ }
+
+ bool gps_detected(void) { return _detected; };
+
+ std::vector<std::string> get_sensors(void) { return _sensors; };
+
+private: // member functions
+ void _thread_fcn()
+ {
+ while (not boost::this_thread::interruption_requested()) {
+ if (!gps_waiting(&_gps_data, CLICK_RATE)) {
+ if (TIMEOUT < _timeout_cnt++)
+ _detected = false;
+ } else {
+ boost::unique_lock<boost::shared_mutex> l(_d_mutex);
+
+ _timeout_cnt = 0;
+ _detected = true;
+
+ if (gps_read(&_gps_data) < 0)
+ throw std::runtime_error("error while reading");
+ }
+ }
+ }
+
+ bool _gps_locked(void)
+ {
+ boost::shared_lock<boost::shared_mutex> l(_d_mutex);
+ return _gps_data.fix.mode >= MODE_2D;
+ }
+
+ std::time_t _epoch_time(void)
+ {
+ boost::shared_lock<boost::shared_mutex> l(_d_mutex);
+ return (boost::posix_time::from_time_t(_gps_data.fix.time)
+ - boost::posix_time::from_time_t(0)).total_seconds();
+ }
+
+ boost::gregorian::date _gregorian_date(void)
+ {
+ boost::shared_lock<boost::shared_mutex> l(_d_mutex);
+ return boost::posix_time::from_time_t(_gps_data.fix.time).date();
+ }
+
+ uhd::dict<std::string, std::string> _gps_position(void)
+ {
+ boost::shared_lock<boost::shared_mutex> l(_d_mutex);
+
+ uhd::dict<std::string, std::string> tmp;
+ if (_gps_data.fix.mode >= MODE_2D) {
+ tmp["lon"] = str(boost::format("%f deg")
+ % _gps_data.fix.longitude);
+ tmp["lat"] = str(boost::format("%f deg")
+ % _gps_data.fix.latitude);
+ tmp["alt"] = str(boost::format("%fm")
+ % _gps_data.fix.altitude);
+ } else {
+ tmp["lon"] = "n/a";
+ tmp["lat"] = "n/a";
+ tmp["alt"] = "n/a";
+ }
+ return tmp;
+ }
+
+private: // members
+ std::vector<std::string> _sensors;
+ bool _detected;
+
+ gps_data_t _gps_data;
+ boost::shared_mutex _d_mutex;
+ boost::thread _bthread;
+ size_t _timeout_cnt;
+};
+
+}} //namespace
+
+using namespace uhd::usrp;
+
+gpsd_iface::sptr gpsd_iface::make(const std::string &addr, const boost::uint16_t port)
+{
+ return gpsd_iface::sptr(new gpsd_iface_impl(addr, port));
+}
diff --git a/host/lib/usrp/gpsd_iface.hpp b/host/lib/usrp/gpsd_iface.hpp
new file mode 100644
index 000000000..7d934ae5c
--- /dev/null
+++ b/host/lib/usrp/gpsd_iface.hpp
@@ -0,0 +1,36 @@
+//
+// Copyright 2015 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_GPSD_IFACE_HPP
+#define INCLUDED_GPSD_IFACE_HPP
+
+#include <boost/cstdint.hpp>
+#include <boost/shared_ptr.hpp>
+
+#include <uhd/usrp/gps_ctrl.hpp>
+
+namespace uhd { namespace usrp {
+
+class gpsd_iface : public virtual uhd::gps_ctrl {
+public:
+ typedef boost::shared_ptr<gpsd_iface> sptr;
+ static sptr make(const std::string &addr, boost::uint16_t port);
+};
+
+}};
+
+#endif /* INCLUDED_GPSD_IFACE_HPP */
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-15 15:47:35 +0000