aboutsummaryrefslogtreecommitdiffstats
path: root/host/lib
diff options
context:
space:
mode:
Diffstat (limited to 'host/lib')
-rw-r--r--host/lib/usrp_clock/multi_usrp_clock.cpp47
-rw-r--r--host/lib/usrp_clock/octoclock/octoclock_eeprom.cpp125
-rw-r--r--host/lib/usrp_clock/octoclock/octoclock_image_loader.cpp327
-rw-r--r--host/lib/usrp_clock/octoclock/octoclock_impl.cpp418
-rw-r--r--host/lib/usrp_clock/octoclock/octoclock_impl.hpp49
-rw-r--r--host/lib/usrp_clock/octoclock/octoclock_uart.cpp268
-rw-r--r--host/lib/usrp_clock/octoclock/octoclock_uart.hpp22
-rw-r--r--host/lib/usrp_clock/usrp_clock_c.cpp156
8 files changed, 753 insertions, 659 deletions
diff --git a/host/lib/usrp_clock/multi_usrp_clock.cpp b/host/lib/usrp_clock/multi_usrp_clock.cpp
index 42dc1eb0b..c4bf081cc 100644
--- a/host/lib/usrp_clock/multi_usrp_clock.cpp
+++ b/host/lib/usrp_clock/multi_usrp_clock.cpp
@@ -5,12 +5,10 @@
// SPDX-License-Identifier: GPL-3.0-or-later
//
+#include <uhd/exception.hpp>
#include <uhd/property_tree.hpp>
#include <uhd/usrp_clock/multi_usrp_clock.hpp>
#include <uhd/usrp_clock/octoclock_eeprom.hpp>
-
-
-#include <uhd/exception.hpp>
#include <uhd/utils/log.hpp>
#include <boost/assign/list_of.hpp>
#include <boost/format.hpp>
@@ -21,48 +19,54 @@ using namespace uhd::usrp_clock;
/***********************************************************************
* Multi USRP Clock implementation
**********************************************************************/
-class multi_usrp_clock_impl : public multi_usrp_clock{
+class multi_usrp_clock_impl : public multi_usrp_clock
+{
public:
- multi_usrp_clock_impl(const device_addr_t &addr){
- _dev = device::make(addr, device::CLOCK);
+ multi_usrp_clock_impl(const device_addr_t& addr)
+ {
+ _dev = device::make(addr, device::CLOCK);
_tree = _dev->get_tree();
}
- device::sptr get_device(void){
+ device::sptr get_device(void)
+ {
return _dev;
}
- std::string get_pp_string(void){
+ std::string get_pp_string(void)
+ {
std::string buff = str(boost::format("%s USRP Clock Device\n")
- % ((get_num_boards() > 1) ? "Multi" : "Single")
- );
- for(size_t i = 0; i < get_num_boards(); i++){
+ % ((get_num_boards() > 1) ? "Multi" : "Single"));
+ for (size_t i = 0; i < get_num_boards(); i++) {
buff += str(boost::format(" Board %s\n") % i);
buff += str(boost::format(" Reference: %s\n")
- % (get_sensor("using_ref", i).value)
- );
+ % (get_sensor("using_ref", i).value));
}
return buff;
}
- size_t get_num_boards(void){
+ size_t get_num_boards(void)
+ {
return _tree->list("/mboards").size();
}
- uint32_t get_time(size_t board){
+ uint32_t get_time(size_t board)
+ {
std::string board_str = str(boost::format("/mboards/%d") % board);
return _tree->access<uint32_t>(board_str / "time").get();
}
- sensor_value_t get_sensor(const std::string &name, size_t board){
+ sensor_value_t get_sensor(const std::string& name, size_t board)
+ {
std::string board_str = str(boost::format("/mboards/%d") % board);
return _tree->access<sensor_value_t>(board_str / "sensors" / name).get();
}
- std::vector<std::string> get_sensor_names(size_t board){
+ std::vector<std::string> get_sensor_names(size_t board)
+ {
std::string board_str = str(boost::format("/mboards/%d") % board);
return _tree->list(board_str / "sensors");
@@ -73,14 +77,17 @@ private:
property_tree::sptr _tree;
};
-multi_usrp_clock::~multi_usrp_clock(void){
+multi_usrp_clock::~multi_usrp_clock(void)
+{
/* NOP */
}
/***********************************************************************
* Multi USRP Clock factory function
**********************************************************************/
-multi_usrp_clock::sptr multi_usrp_clock::make(const device_addr_t &dev_addr){
- UHD_LOGGER_TRACE("OCTOCLOCK") << "multi_usrp_clock::make with args " << dev_addr.to_pp_string() ;
+multi_usrp_clock::sptr multi_usrp_clock::make(const device_addr_t& dev_addr)
+{
+ UHD_LOGGER_TRACE("OCTOCLOCK")
+ << "multi_usrp_clock::make with args " << dev_addr.to_pp_string();
return sptr(new multi_usrp_clock_impl(dev_addr));
}
diff --git a/host/lib/usrp_clock/octoclock/octoclock_eeprom.cpp b/host/lib/usrp_clock/octoclock/octoclock_eeprom.cpp
index a9f91897e..349d704f3 100644
--- a/host/lib/usrp_clock/octoclock/octoclock_eeprom.cpp
+++ b/host/lib/usrp_clock/octoclock/octoclock_eeprom.cpp
@@ -5,20 +5,18 @@
// SPDX-License-Identifier: GPL-3.0-or-later
//
+#include "common.h"
#include <uhd/exception.hpp>
-#include <uhd/usrp_clock/octoclock_eeprom.hpp>
#include <uhd/transport/udp_simple.hpp>
-#include <uhd/usrp/mboard_eeprom.hpp>
#include <uhd/types/byte_vector.hpp>
#include <uhd/types/mac_addr.hpp>
+#include <uhd/usrp/mboard_eeprom.hpp>
+#include <uhd/usrp_clock/octoclock_eeprom.hpp>
#include <uhd/utils/byteswap.hpp>
-#include <boost/assign/list_of.hpp>
#include <boost/asio.hpp>
-
+#include <boost/assign/list_of.hpp>
#include <iostream>
-#include "common.h"
-
typedef boost::asio::ip::address_v4 ip_v4;
using namespace uhd;
@@ -28,129 +26,146 @@ using namespace uhd::transport;
/***********************************************************************
* Implementation
**********************************************************************/
-void octoclock_eeprom_t::_load(){
+void octoclock_eeprom_t::_load()
+{
uint8_t octoclock_data[udp_simple::mtu];
- const octoclock_packet_t *pkt_in = reinterpret_cast<const octoclock_packet_t*>(octoclock_data);
- const octoclock_fw_eeprom_t *eeprom_in = reinterpret_cast<const octoclock_fw_eeprom_t*>(pkt_in->data);
+ const octoclock_packet_t* pkt_in =
+ reinterpret_cast<const octoclock_packet_t*>(octoclock_data);
+ const octoclock_fw_eeprom_t* eeprom_in =
+ reinterpret_cast<const octoclock_fw_eeprom_t*>(pkt_in->data);
octoclock_packet_t pkt_out;
// To avoid replicating sequence numbers between sessions
pkt_out.sequence = uint32_t(std::rand());
- size_t len = 0;
+ size_t len = 0;
- UHD_OCTOCLOCK_SEND_AND_RECV(xport, _proto_ver, SEND_EEPROM_CMD, pkt_out, len, octoclock_data);
- if(UHD_OCTOCLOCK_PACKET_MATCHES(SEND_EEPROM_ACK, pkt_out, pkt_in, len)){
- //MAC address
- byte_vector_t mac_bytes(eeprom_in->mac_addr, eeprom_in->mac_addr+6);
+ UHD_OCTOCLOCK_SEND_AND_RECV(
+ xport, _proto_ver, SEND_EEPROM_CMD, pkt_out, len, octoclock_data);
+ if (UHD_OCTOCLOCK_PACKET_MATCHES(SEND_EEPROM_ACK, pkt_out, pkt_in, len)) {
+ // MAC address
+ byte_vector_t mac_bytes(eeprom_in->mac_addr, eeprom_in->mac_addr + 6);
(*this)["mac-addr"] = mac_addr_t::from_bytes(mac_bytes).to_string();
- //IP address
+ // IP address
uint32_t ip_addr = uhd::htonx<uint32_t>(eeprom_in->ip_addr);
ip_v4::bytes_type ip_addr_bytes;
memcpy(&ip_addr_bytes, &ip_addr, 4);
(*this)["ip-addr"] = ip_v4(ip_addr_bytes).to_string();
- //Default router
+ // Default router
uint32_t dr_addr = uhd::htonx<uint32_t>(eeprom_in->dr_addr);
ip_v4::bytes_type dr_addr_bytes;
memcpy(&dr_addr_bytes, &dr_addr, 4);
(*this)["gateway"] = ip_v4(dr_addr_bytes).to_string();
- //Netmask
+ // Netmask
uint32_t netmask = uhd::htonx<uint32_t>(eeprom_in->netmask);
ip_v4::bytes_type netmask_bytes;
memcpy(&netmask_bytes, &netmask, 4);
(*this)["netmask"] = ip_v4(netmask_bytes).to_string();
- //Serial
+ // Serial
std::string raw_serial((char*)eeprom_in->serial, 10);
byte_vector_t serial_bytes(raw_serial.begin(), raw_serial.end());
(*this)["serial"] = bytes_to_string(serial_bytes);
- //Name
+ // Name
std::string raw_name((char*)eeprom_in->name, 10);
byte_vector_t name_bytes(raw_name.begin(), raw_name.end());
(*this)["name"] = bytes_to_string(name_bytes);
- //Revision
+ // Revision
(*this)["revision"] = std::to_string(int(eeprom_in->revision));
- }
- else throw uhd::runtime_error("Error loading OctoClock EEPROM.");
+ } else
+ throw uhd::runtime_error("Error loading OctoClock EEPROM.");
}
-void octoclock_eeprom_t::_store() const {
+void octoclock_eeprom_t::_store() const
+{
uint8_t octoclock_data[udp_simple::mtu];
- const octoclock_packet_t *pkt_in = reinterpret_cast<const octoclock_packet_t *>(octoclock_data);
+ const octoclock_packet_t* pkt_in =
+ reinterpret_cast<const octoclock_packet_t*>(octoclock_data);
octoclock_packet_t pkt_out;
// To avoid replicating sequence numbers between sessions
pkt_out.sequence = uint32_t(std::rand());
- pkt_out.len = sizeof(octoclock_fw_eeprom_t);
- size_t len = 0;
+ pkt_out.len = sizeof(octoclock_fw_eeprom_t);
+ size_t len = 0;
- octoclock_fw_eeprom_t *eeprom_out = reinterpret_cast<octoclock_fw_eeprom_t *>(&pkt_out.data);
+ octoclock_fw_eeprom_t* eeprom_out =
+ reinterpret_cast<octoclock_fw_eeprom_t*>(&pkt_out.data);
memset(eeprom_out, 0xFF, sizeof(octoclock_fw_eeprom_t));
- //MAC address
- if((*this).has_key("mac-addr")){
- byte_copy(mac_addr_t::from_string((*this)["mac-addr"]).to_bytes(), eeprom_out->mac_addr);
+ // MAC address
+ if ((*this).has_key("mac-addr")) {
+ byte_copy(mac_addr_t::from_string((*this)["mac-addr"]).to_bytes(),
+ eeprom_out->mac_addr);
}
- //IP address
- if((*this).has_key("ip-addr")){
- ip_v4::bytes_type ip_addr_bytes = ip_v4::from_string((*this)["ip-addr"]).to_bytes();
+ // IP address
+ if ((*this).has_key("ip-addr")) {
+ ip_v4::bytes_type ip_addr_bytes =
+ ip_v4::from_string((*this)["ip-addr"]).to_bytes();
memcpy(&eeprom_out->ip_addr, &ip_addr_bytes, 4);
eeprom_out->ip_addr = uhd::htonx<uint32_t>(eeprom_out->ip_addr);
}
- //Default router
- if((*this).has_key("gateway")){
- ip_v4::bytes_type dr_addr_bytes = ip_v4::from_string((*this)["gateway"]).to_bytes();
+ // Default router
+ if ((*this).has_key("gateway")) {
+ ip_v4::bytes_type dr_addr_bytes =
+ ip_v4::from_string((*this)["gateway"]).to_bytes();
memcpy(&eeprom_out->dr_addr, &dr_addr_bytes, 4);
eeprom_out->dr_addr = uhd::htonx<uint32_t>(eeprom_out->dr_addr);
}
- //Netmask
- if((*this).has_key("netmask")){
- ip_v4::bytes_type netmask_bytes = ip_v4::from_string((*this)["netmask"]).to_bytes();
+ // Netmask
+ if ((*this).has_key("netmask")) {
+ ip_v4::bytes_type netmask_bytes =
+ ip_v4::from_string((*this)["netmask"]).to_bytes();
memcpy(&eeprom_out->netmask, &netmask_bytes, 4);
eeprom_out->netmask = uhd::htonx<uint32_t>(eeprom_out->netmask);
}
- //Serial
- if((*this).has_key("serial")){
- byte_copy(byte_vector_t((*this)["serial"].begin(), (*this)["serial"].end()), eeprom_out->serial);
+ // Serial
+ if ((*this).has_key("serial")) {
+ byte_copy(byte_vector_t((*this)["serial"].begin(), (*this)["serial"].end()),
+ eeprom_out->serial);
}
- //Name
- if((*this).has_key("name")){
- byte_copy(byte_vector_t((*this)["name"].begin(), (*this)["name"].end()), eeprom_out->name);
+ // Name
+ if ((*this).has_key("name")) {
+ byte_copy(byte_vector_t((*this)["name"].begin(), (*this)["name"].end()),
+ eeprom_out->name);
}
- //Revision
- if((*this).has_key("revision")){
- eeprom_out->revision = (*this)["revision"][0]-'0';
+ // Revision
+ if ((*this).has_key("revision")) {
+ eeprom_out->revision = (*this)["revision"][0] - '0';
}
- UHD_OCTOCLOCK_SEND_AND_RECV(xport, _proto_ver, BURN_EEPROM_CMD, pkt_out, len, octoclock_data);
- if(not UHD_OCTOCLOCK_PACKET_MATCHES(BURN_EEPROM_SUCCESS_ACK, pkt_out, pkt_in, len))
+ UHD_OCTOCLOCK_SEND_AND_RECV(
+ xport, _proto_ver, BURN_EEPROM_CMD, pkt_out, len, octoclock_data);
+ if (not UHD_OCTOCLOCK_PACKET_MATCHES(BURN_EEPROM_SUCCESS_ACK, pkt_out, pkt_in, len))
throw uhd::runtime_error("Error writing to OctoClock EEPROM.");
}
/***********************************************************************
* Implementation of OctoClock EEPROM
**********************************************************************/
-octoclock_eeprom_t::octoclock_eeprom_t(void){
+octoclock_eeprom_t::octoclock_eeprom_t(void)
+{
/* NOP */
}
-octoclock_eeprom_t::octoclock_eeprom_t(udp_simple::sptr transport, uint32_t proto_ver) :
- xport(transport), _proto_ver(proto_ver)
+octoclock_eeprom_t::octoclock_eeprom_t(udp_simple::sptr transport, uint32_t proto_ver)
+ : xport(transport), _proto_ver(proto_ver)
{
_load();
}
-void octoclock_eeprom_t::commit() const{
- if(!xport) throw uhd::runtime_error("There is no set device communication.");
+void octoclock_eeprom_t::commit() const
+{
+ if (!xport)
+ throw uhd::runtime_error("There is no set device communication.");
_store();
}
diff --git a/host/lib/usrp_clock/octoclock/octoclock_image_loader.cpp b/host/lib/usrp_clock/octoclock/octoclock_image_loader.cpp
index e030e6106..02a243b70 100644
--- a/host/lib/usrp_clock/octoclock/octoclock_image_loader.cpp
+++ b/host/lib/usrp_clock/octoclock/octoclock_image_loader.cpp
@@ -5,9 +5,8 @@
// SPDX-License-Identifier: GPL-3.0-or-later
//
-#include "octoclock_impl.hpp"
#include "common.h"
-
+#include "octoclock_impl.hpp"
#include <uhd/device.hpp>
#include <uhd/image_loader.hpp>
#include <uhd/transport/udp_simple.hpp>
@@ -17,61 +16,63 @@
#include <uhd/utils/paths.hpp>
#include <uhd/utils/static.hpp>
#include <uhdlib/utils/ihex.hpp>
-
+#include <stdint.h>
#include <boost/filesystem.hpp>
#include <boost/format.hpp>
-
#include <algorithm>
-#include <iterator>
+#include <chrono>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <iostream>
+#include <iterator>
#include <string>
-#include <chrono>
#include <thread>
-#include <stdint.h>
namespace fs = boost::filesystem;
using namespace uhd;
using namespace uhd::usrp_clock;
using namespace uhd::transport;
-#define OCTOCLOCK_FIRMWARE_MAX_SIZE_BYTES (1024*120) // Last 8 MB are for bootloader
-#define OCTOCLOCK_BLOCK_SIZE 256
+#define OCTOCLOCK_FIRMWARE_MAX_SIZE_BYTES (1024 * 120) // Last 8 MB are for bootloader
+#define OCTOCLOCK_BLOCK_SIZE 256
/*
* OctoClock burn session
*/
-typedef struct {
- bool found;
- uhd::device_addr_t dev_addr;
- std::string image_filepath;
- uint16_t crc;
- uint16_t num_blocks;
- uint32_t sequence;
- udp_simple::sptr ctrl_xport;
- udp_simple::sptr fw_xport;
- uint8_t data_in[udp_simple::mtu];
- uint32_t starting_firmware_version;
+typedef struct
+{
+ bool found;
+ uhd::device_addr_t dev_addr;
+ std::string image_filepath;
+ uint16_t crc;
+ uint16_t num_blocks;
+ uint32_t sequence;
+ udp_simple::sptr ctrl_xport;
+ udp_simple::sptr fw_xport;
+ uint8_t data_in[udp_simple::mtu];
+ uint32_t starting_firmware_version;
std::vector<uint8_t> image;
} octoclock_session_t;
-static void octoclock_calculate_crc(octoclock_session_t &session){
+static void octoclock_calculate_crc(octoclock_session_t& session)
+{
session.crc = 0xFFFF;
- for(size_t i = 0; i < session.image.size(); i++)
- {
+ for (size_t i = 0; i < session.image.size(); i++) {
session.crc ^= session.image[i];
- for(uint8_t j = 0; j < 8; ++j){
- if(session.crc & 1) session.crc = (session.crc >> 1) ^ 0xA001;
- else session.crc = (session.crc >> 1);
+ for (uint8_t j = 0; j < 8; ++j) {
+ if (session.crc & 1)
+ session.crc = (session.crc >> 1) ^ 0xA001;
+ else
+ session.crc = (session.crc >> 1);
}
}
}
-static void octoclock_read_bin(octoclock_session_t &session)
+static void octoclock_read_bin(octoclock_session_t& session)
{
- std::ifstream bin_file(session.image_filepath.c_str(), std::ios::in | std::ios::binary);
+ std::ifstream bin_file(
+ session.image_filepath.c_str(), std::ios::in | std::ios::binary);
if (not bin_file.is_open()) {
throw uhd::io_error("Could not read image file.");
}
@@ -80,183 +81,197 @@ static void octoclock_read_bin(octoclock_session_t &session)
session.image.clear();
session.image.resize(filesize);
bin_file.read((char*)&session.image[0], filesize);
- if(size_t(bin_file.gcount()) != filesize) {
+ if (size_t(bin_file.gcount()) != filesize) {
throw uhd::io_error("Failed to read firmware image.");
}
bin_file.close();
}
-static void octoclock_validate_firmware_image(octoclock_session_t &session){
- if(not fs::exists(session.image_filepath)){
+static void octoclock_validate_firmware_image(octoclock_session_t& session)
+{
+ if (not fs::exists(session.image_filepath)) {
throw uhd::runtime_error(str(boost::format("Could not find image at path \"%s\"")
% session.image_filepath));
}
std::string extension = fs::extension(session.image_filepath);
- if(extension == ".bin"){
+ if (extension == ".bin") {
octoclock_read_bin(session);
- }
- else if(extension == ".hex"){
+ } else if (extension == ".hex") {
ihex_reader hex_reader(session.image_filepath);
session.image = hex_reader.to_vector(OCTOCLOCK_FIRMWARE_MAX_SIZE_BYTES);
- }
- else throw uhd::runtime_error(str(boost::format("Invalid extension \"%s\". Extension must be .hex or .bin.")
- % extension));
-
- if(session.image.size() > OCTOCLOCK_FIRMWARE_MAX_SIZE_BYTES){
- throw uhd::runtime_error(str(boost::format("The specified firmware image is too large: %d vs. %d")
- % session.image.size() % OCTOCLOCK_FIRMWARE_MAX_SIZE_BYTES));
+ } else
+ throw uhd::runtime_error(
+ str(boost::format("Invalid extension \"%s\". Extension must be .hex or .bin.")
+ % extension));
+
+ if (session.image.size() > OCTOCLOCK_FIRMWARE_MAX_SIZE_BYTES) {
+ throw uhd::runtime_error(
+ str(boost::format("The specified firmware image is too large: %d vs. %d")
+ % session.image.size() % OCTOCLOCK_FIRMWARE_MAX_SIZE_BYTES));
}
session.num_blocks = (session.image.size() % OCTOCLOCK_BLOCK_SIZE)
- ? ((session.image.size() / OCTOCLOCK_BLOCK_SIZE) + 1)
- : (session.image.size() / OCTOCLOCK_BLOCK_SIZE);
+ ? ((session.image.size() / OCTOCLOCK_BLOCK_SIZE) + 1)
+ : (session.image.size() / OCTOCLOCK_BLOCK_SIZE);
octoclock_calculate_crc(session);
}
-static void octoclock_setup_session(octoclock_session_t &session,
- const uhd::device_addr_t &args,
- const std::string &filepath){
-
+static void octoclock_setup_session(octoclock_session_t& session,
+ const uhd::device_addr_t& args,
+ const std::string& filepath)
+{
// See if we can find an OctoClock with the given args
device_addrs_t devs = octoclock_find(args);
- if(devs.size() == 0){
+ if (devs.size() == 0) {
session.found = false;
return;
- }
- else if(devs.size() > 1){
- std::string err_msg = "Could not resolve given args to a single OctoClock device.\n"
- "Applicable devices:\n";
-
- for(const uhd::device_addr_t &dev: devs){
- std::string name = (dev["type"] == "octoclock") ? str(boost::format("OctoClock r%d")
- % dev.get("revision","4"))
- : "OctoClock Bootloader";
- err_msg += str(boost::format(" * %s (addr=%s)\n")
- % name
- % dev.get("addr"));
+ } else if (devs.size() > 1) {
+ std::string err_msg =
+ "Could not resolve given args to a single OctoClock device.\n"
+ "Applicable devices:\n";
+
+ for (const uhd::device_addr_t& dev : devs) {
+ std::string name =
+ (dev["type"] == "octoclock")
+ ? str(boost::format("OctoClock r%d") % dev.get("revision", "4"))
+ : "OctoClock Bootloader";
+ err_msg += str(boost::format(" * %s (addr=%s)\n") % name % dev.get("addr"));
}
- err_msg += "\nSpecify one of these devices with the given args to load an image onto it.";
+ err_msg += "\nSpecify one of these devices with the given args to load an image "
+ "onto it.";
throw uhd::runtime_error(err_msg);
}
session.dev_addr = devs[0];
- session.found = true;
+ session.found = true;
// If no filepath is given, use the default
- if(filepath == ""){
- session.image_filepath = find_image_path(str(boost::format("octoclock_r%s_fw.hex")
- % session.dev_addr.get("revision","4")
- ));
- }
- else session.image_filepath = filepath;
+ if (filepath == "") {
+ session.image_filepath =
+ find_image_path(str(boost::format("octoclock_r%s_fw.hex")
+ % session.dev_addr.get("revision", "4")));
+ } else
+ session.image_filepath = filepath;
octoclock_validate_firmware_image(session);
- session.ctrl_xport = udp_simple::make_connected(session.dev_addr["addr"],
- BOOST_STRINGIZE(OCTOCLOCK_UDP_CTRL_PORT));
- session.fw_xport = udp_simple::make_connected(session.dev_addr["addr"],
- BOOST_STRINGIZE(OCTOCLOCK_UDP_FW_PORT));
+ session.ctrl_xport = udp_simple::make_connected(
+ session.dev_addr["addr"], BOOST_STRINGIZE(OCTOCLOCK_UDP_CTRL_PORT));
+ session.fw_xport = udp_simple::make_connected(
+ session.dev_addr["addr"], BOOST_STRINGIZE(OCTOCLOCK_UDP_FW_PORT));
// To avoid replicating sequence numbers between sessions
- session.sequence = uint32_t(std::rand());
+ session.sequence = uint32_t(std::rand());
// Query OctoClock again to get compat number
octoclock_packet_t pkt_out;
- const octoclock_packet_t* pkt_in = reinterpret_cast<const octoclock_packet_t*>(session.data_in);
+ const octoclock_packet_t* pkt_in =
+ reinterpret_cast<const octoclock_packet_t*>(session.data_in);
size_t len = 0;
- UHD_OCTOCLOCK_SEND_AND_RECV(session.ctrl_xport, OCTOCLOCK_FW_COMPAT_NUM, OCTOCLOCK_QUERY_CMD, pkt_out, len, session.data_in);
- if(UHD_OCTOCLOCK_PACKET_MATCHES(OCTOCLOCK_QUERY_ACK, pkt_out, pkt_in, len)){
+ UHD_OCTOCLOCK_SEND_AND_RECV(session.ctrl_xport,
+ OCTOCLOCK_FW_COMPAT_NUM,
+ OCTOCLOCK_QUERY_CMD,
+ pkt_out,
+ len,
+ session.data_in);
+ if (UHD_OCTOCLOCK_PACKET_MATCHES(OCTOCLOCK_QUERY_ACK, pkt_out, pkt_in, len)) {
session.starting_firmware_version = uhd::htonx<uint32_t>(pkt_in->proto_ver);
} else {
throw uhd::runtime_error("Failed to communicate with OctoClock.");
}
}
-static void octoclock_reset_into_bootloader(octoclock_session_t &session){
-
+static void octoclock_reset_into_bootloader(octoclock_session_t& session)
+{
// Already in bootloader
- if(session.dev_addr["type"] == "octoclock-bootloader")
+ if (session.dev_addr["type"] == "octoclock-bootloader")
return;
// Force compat num to device's current, works around old firmware bug
octoclock_packet_t pkt_out;
- pkt_out.sequence = uhd::htonx<uint32_t>(++session.sequence);
+ pkt_out.sequence = uhd::htonx<uint32_t>(++session.sequence);
pkt_out.proto_ver = uhd::htonx<uint32_t>(session.starting_firmware_version);
- pkt_out.code = RESET_CMD;
+ pkt_out.code = RESET_CMD;
std::cout << " -- Resetting into bootloader..." << std::flush;
- session.ctrl_xport->send(boost::asio::buffer(&pkt_out, sizeof(octoclock_packet_t))); \
- size_t len = session.ctrl_xport->recv(boost::asio::buffer(session.data_in), 2);\
- const octoclock_packet_t* pkt_in = reinterpret_cast<const octoclock_packet_t*>(session.data_in);
+ session.ctrl_xport->send(boost::asio::buffer(&pkt_out, sizeof(octoclock_packet_t)));
+ size_t len = session.ctrl_xport->recv(boost::asio::buffer(session.data_in), 2);
+ const octoclock_packet_t* pkt_in =
+ reinterpret_cast<const octoclock_packet_t*>(session.data_in);
- if(UHD_OCTOCLOCK_PACKET_MATCHES(RESET_ACK, pkt_out, pkt_in, len)){
+ if (UHD_OCTOCLOCK_PACKET_MATCHES(RESET_ACK, pkt_out, pkt_in, len)) {
// Make sure this device is now in its bootloader
std::this_thread::sleep_for(std::chrono::milliseconds(500));
uhd::device_addrs_t octoclocks = uhd::device::find(
- uhd::device_addr_t(str(boost::format("addr=%s")
- % session.dev_addr["addr"]
- )));
- if(octoclocks.size() == 0){
+ uhd::device_addr_t(str(boost::format("addr=%s") % session.dev_addr["addr"])));
+ if (octoclocks.size() == 0) {
std::cout << "failed." << std::endl;
throw uhd::runtime_error("Failed to reset OctoClock.");
- }
- else if(octoclocks[0]["type"] != "octoclock-bootloader"){
+ } else if (octoclocks[0]["type"] != "octoclock-bootloader") {
std::cout << "failed." << std::endl;
throw uhd::runtime_error("Failed to reset OctoClock.");
- }
- else{
+ } else {
std::cout << "successful." << std::endl;
session.dev_addr = octoclocks[0];
}
- }
- else{
+ } else {
std::cout << "failed." << std::endl;
throw uhd::runtime_error("Failed to reset OctoClock.");
}
}
-static void octoclock_burn(octoclock_session_t &session){
-
+static void octoclock_burn(octoclock_session_t& session)
+{
// Make sure we're in the bootloader for this
octoclock_reset_into_bootloader(session);
octoclock_packet_t pkt_out;
pkt_out.sequence = uhd::htonx<uint32_t>(++session.sequence);
- const octoclock_packet_t* pkt_in = reinterpret_cast<const octoclock_packet_t*>(session.data_in);
+ const octoclock_packet_t* pkt_in =
+ reinterpret_cast<const octoclock_packet_t*>(session.data_in);
// Tell OctoClock to prepare for burn
pkt_out.len = htonx<uint16_t>(session.image.size());
- size_t len = 0;
+ size_t len = 0;
std::cout << " -- Preparing OctoClock for firmware load..." << std::flush;
pkt_out.len = session.image.size();
pkt_out.crc = session.crc;
- UHD_OCTOCLOCK_SEND_AND_RECV(session.fw_xport, OCTOCLOCK_FW_COMPAT_NUM, PREPARE_FW_BURN_CMD, pkt_out, len, session.data_in);
- if(UHD_OCTOCLOCK_PACKET_MATCHES(FW_BURN_READY_ACK, pkt_out, pkt_in, len)){
+ UHD_OCTOCLOCK_SEND_AND_RECV(session.fw_xport,
+ OCTOCLOCK_FW_COMPAT_NUM,
+ PREPARE_FW_BURN_CMD,
+ pkt_out,
+ len,
+ session.data_in);
+ if (UHD_OCTOCLOCK_PACKET_MATCHES(FW_BURN_READY_ACK, pkt_out, pkt_in, len)) {
std::cout << "successful." << std::endl;
- }
- else{
+ } else {
std::cout << "failed." << std::endl;
throw uhd::runtime_error("Failed to prepare OctoClock for firmware load.");
}
// Start burning
- for(size_t i = 0; i < session.num_blocks; i++){
+ for (size_t i = 0; i < session.num_blocks; i++) {
pkt_out.sequence = uhd::htonx<uint32_t>(++session.sequence);
- pkt_out.addr = i * OCTOCLOCK_BLOCK_SIZE;
+ pkt_out.addr = i * OCTOCLOCK_BLOCK_SIZE;
std::cout << str(boost::format("\r -- Loading firmware: %d%% (%d/%d blocks)")
- % int((double(i)/double(session.num_blocks))*100)
- % i % session.num_blocks)
+ % int((double(i) / double(session.num_blocks)) * 100) % i
+ % session.num_blocks)
<< std::flush;
memset(pkt_out.data, 0, OCTOCLOCK_BLOCK_SIZE);
memcpy((char*)pkt_out.data, &session.image[pkt_out.addr], OCTOCLOCK_BLOCK_SIZE);
- UHD_OCTOCLOCK_SEND_AND_RECV(session.fw_xport, OCTOCLOCK_FW_COMPAT_NUM, FILE_TRANSFER_CMD, pkt_out, len, session.data_in);
- if(not UHD_OCTOCLOCK_PACKET_MATCHES(FILE_TRANSFER_ACK, pkt_out, pkt_in, len)){
+ UHD_OCTOCLOCK_SEND_AND_RECV(session.fw_xport,
+ OCTOCLOCK_FW_COMPAT_NUM,
+ FILE_TRANSFER_CMD,
+ pkt_out,
+ len,
+ session.data_in);
+ if (not UHD_OCTOCLOCK_PACKET_MATCHES(FILE_TRANSFER_ACK, pkt_out, pkt_in, len)) {
std::cout << std::endl;
throw uhd::runtime_error("Failed to load firmware.");
}
@@ -267,36 +282,43 @@ static void octoclock_burn(octoclock_session_t &session){
<< std::endl;
}
-static void octoclock_verify(octoclock_session_t &session){
-
+static void octoclock_verify(octoclock_session_t& session)
+{
octoclock_packet_t pkt_out;
pkt_out.sequence = uhd::htonx<uint32_t>(++session.sequence);
- const octoclock_packet_t* pkt_in = reinterpret_cast<const octoclock_packet_t*>(session.data_in);
+ const octoclock_packet_t* pkt_in =
+ reinterpret_cast<const octoclock_packet_t*>(session.data_in);
size_t len = 0;
uint8_t image_part[OCTOCLOCK_BLOCK_SIZE];
uint16_t cmp_len = 0;
- for(size_t i = 0; i < session.num_blocks; i++){
+ for (size_t i = 0; i < session.num_blocks; i++) {
pkt_out.sequence = uhd::htonx<uint32_t>(++session.sequence);
- pkt_out.addr = i * OCTOCLOCK_BLOCK_SIZE;
+ pkt_out.addr = i * OCTOCLOCK_BLOCK_SIZE;
- std::cout << str(boost::format("\r -- Verifying firmware load: %d%% (%d/%d blocks)")
- % int((double(i)/double(session.num_blocks))*100)
- % i % session.num_blocks)
+ std::cout << str(boost::format(
+ "\r -- Verifying firmware load: %d%% (%d/%d blocks)")
+ % int((double(i) / double(session.num_blocks)) * 100) % i
+ % session.num_blocks)
<< std::flush;
memset(image_part, 0, OCTOCLOCK_BLOCK_SIZE);
memcpy((char*)image_part, &session.image[pkt_out.addr], OCTOCLOCK_BLOCK_SIZE);
- cmp_len = std::min<size_t>(OCTOCLOCK_BLOCK_SIZE, session.image.size() - size_t(pkt_out.addr));
-
- UHD_OCTOCLOCK_SEND_AND_RECV(session.fw_xport, OCTOCLOCK_FW_COMPAT_NUM, READ_FW_CMD, pkt_out, len, session.data_in);
- if(UHD_OCTOCLOCK_PACKET_MATCHES(READ_FW_ACK, pkt_out, pkt_in, len)){
- if(memcmp(pkt_in->data, image_part, cmp_len)){
+ cmp_len = std::min<size_t>(
+ OCTOCLOCK_BLOCK_SIZE, session.image.size() - size_t(pkt_out.addr));
+
+ UHD_OCTOCLOCK_SEND_AND_RECV(session.fw_xport,
+ OCTOCLOCK_FW_COMPAT_NUM,
+ READ_FW_CMD,
+ pkt_out,
+ len,
+ session.data_in);
+ if (UHD_OCTOCLOCK_PACKET_MATCHES(READ_FW_ACK, pkt_out, pkt_in, len)) {
+ if (memcmp(pkt_in->data, image_part, cmp_len)) {
std::cout << std::endl;
throw uhd::runtime_error("Failed to verify OctoClock firmware.");
}
- }
- else{
+ } else {
std::cout << std::endl;
throw uhd::runtime_error("Failed to verify OctoClock firmware.");
}
@@ -307,34 +329,38 @@ static void octoclock_verify(octoclock_session_t &session){
<< std::endl;
}
-static void octoclock_finalize(octoclock_session_t &session){
-
+static void octoclock_finalize(octoclock_session_t& session)
+{
octoclock_packet_t pkt_out;
pkt_out.sequence = uhd::htonx<uint32_t>(++session.sequence);
- const octoclock_packet_t* pkt_in = reinterpret_cast<const octoclock_packet_t*>(session.data_in);
+ const octoclock_packet_t* pkt_in =
+ reinterpret_cast<const octoclock_packet_t*>(session.data_in);
size_t len = 0;
std::cout << " -- Finalizing firmware load..." << std::flush;
- UHD_OCTOCLOCK_SEND_AND_RECV(session.fw_xport, OCTOCLOCK_FW_COMPAT_NUM, FINALIZE_BURNING_CMD, pkt_out, len, session.data_in);
- if(UHD_OCTOCLOCK_PACKET_MATCHES(FINALIZE_BURNING_ACK, pkt_out, pkt_in, len)){
+ UHD_OCTOCLOCK_SEND_AND_RECV(session.fw_xport,
+ OCTOCLOCK_FW_COMPAT_NUM,
+ FINALIZE_BURNING_CMD,
+ pkt_out,
+ len,
+ session.data_in);
+ if (UHD_OCTOCLOCK_PACKET_MATCHES(FINALIZE_BURNING_ACK, pkt_out, pkt_in, len)) {
std::cout << "successful." << std::endl;
- }
- else{
+ } else {
std::cout << "failed." << std::endl;
throw uhd::runtime_error("Failed to finalize OctoClock firmware load.");
}
}
-bool octoclock_image_loader(const image_loader::image_loader_args_t &image_loader_args){
+bool octoclock_image_loader(const image_loader::image_loader_args_t& image_loader_args)
+{
octoclock_session_t session;
- octoclock_setup_session(session,
- image_loader_args.args,
- image_loader_args.firmware_path
- );
- if(!session.found or !image_loader_args.load_firmware) return false;
-
- std::cout << boost::format("Unit: OctoClock (%s)")
- % session.dev_addr["addr"]
+ octoclock_setup_session(
+ session, image_loader_args.args, image_loader_args.firmware_path);
+ if (!session.found or !image_loader_args.load_firmware)
+ return false;
+
+ std::cout << boost::format("Unit: OctoClock (%s)") % session.dev_addr["addr"]
<< std::endl;
std::cout << "Firmware: " << session.image_filepath << std::endl;
@@ -345,14 +371,15 @@ bool octoclock_image_loader(const image_loader::image_loader_args_t &image_loade
return true;
}
-UHD_STATIC_BLOCK(register_octoclock_image_loader){
- std::string recovery_instructions = "Aborting. Your OctoClock firmware is now corrupt. The bootloader\n"
- "is functional, but the device will not have functional clock distribution.\n"
- "Run this utility again to restore functionality or refer to:\n\n"
- "http://files.ettus.com/manual/page_octoclock.html\n\n"
- "for alternative setups.";
-
- image_loader::register_image_loader("octoclock",
- octoclock_image_loader,
- recovery_instructions);
+UHD_STATIC_BLOCK(register_octoclock_image_loader)
+{
+ std::string recovery_instructions =
+ "Aborting. Your OctoClock firmware is now corrupt. The bootloader\n"
+ "is functional, but the device will not have functional clock distribution.\n"
+ "Run this utility again to restore functionality or refer to:\n\n"
+ "http://files.ettus.com/manual/page_octoclock.html\n\n"
+ "for alternative setups.";
+
+ image_loader::register_image_loader(
+ "octoclock", octoclock_image_loader, recovery_instructions);
}
diff --git a/host/lib/usrp_clock/octoclock/octoclock_impl.cpp b/host/lib/usrp_clock/octoclock/octoclock_impl.cpp
index a1891c7bd..b7ebc3473 100644
--- a/host/lib/usrp_clock/octoclock/octoclock_impl.cpp
+++ b/host/lib/usrp_clock/octoclock/octoclock_impl.cpp
@@ -24,154 +24,168 @@
#include <boost/assign.hpp>
#include <boost/filesystem.hpp>
#include <boost/format.hpp>
+#include <boost/thread.hpp>
using namespace uhd;
using namespace uhd::usrp_clock;
using namespace uhd::transport;
namespace asio = boost::asio;
-namespace fs = boost::filesystem;
+namespace fs = boost::filesystem;
/***********************************************************************
* Discovery
**********************************************************************/
-device_addrs_t octoclock_find(const device_addr_t &hint){
- //Handle the multi-device discovery
+device_addrs_t octoclock_find(const device_addr_t& hint)
+{
+ // Handle the multi-device discovery
device_addrs_t hints = separate_device_addr(hint);
- if (hints.size() > 1){
+ if (hints.size() > 1) {
device_addrs_t found_devices;
std::string error_msg;
- for(const device_addr_t &hint_i: hints){
+ for (const device_addr_t& hint_i : hints) {
device_addrs_t found_devices_i = octoclock_find(hint_i);
- if (found_devices_i.size() != 1) error_msg += str(boost::format(
- "Could not resolve device hint \"%s\" to a single device."
- ) % hint_i.to_string());
- else found_devices.push_back(found_devices_i[0]);
+ if (found_devices_i.size() != 1)
+ error_msg +=
+ str(boost::format(
+ "Could not resolve device hint \"%s\" to a single device.")
+ % hint_i.to_string());
+ else
+ found_devices.push_back(found_devices_i[0]);
}
- if (found_devices.empty()) return device_addrs_t();
- if (not error_msg.empty()) throw uhd::value_error(error_msg);
+ if (found_devices.empty())
+ return device_addrs_t();
+ if (not error_msg.empty())
+ throw uhd::value_error(error_msg);
return device_addrs_t(1, combine_device_addrs(found_devices));
}
- //Initialize the hint for a single device case
+ // Initialize the hint for a single device case
UHD_ASSERT_THROW(hints.size() <= 1);
- hints.resize(1); //In case it was empty
+ hints.resize(1); // In case it was empty
device_addr_t _hint = hints[0];
device_addrs_t octoclock_addrs;
- //return an empty list of addresses when type is set to non-OctoClock
- if (hint.has_key("type") and hint["type"].find("octoclock") == std::string::npos) return octoclock_addrs;
+ // return an empty list of addresses when type is set to non-OctoClock
+ if (hint.has_key("type") and hint["type"].find("octoclock") == std::string::npos)
+ return octoclock_addrs;
- //Return an empty list of addresses when a resource is specified,
- //since a resource is intended for a different, non-USB, device.
- if (hint.has_key("resource")) return octoclock_addrs;
+ // Return an empty list of addresses when a resource is specified,
+ // since a resource is intended for a different, non-USB, device.
+ if (hint.has_key("resource"))
+ return octoclock_addrs;
- //If no address was specified, send a broadcast on each interface
- if (not _hint.has_key("addr")){
- for(const if_addrs_t &if_addrs: get_if_addrs()){
- //avoid the loopback device
- if (if_addrs.inet == asio::ip::address_v4::loopback().to_string()) continue;
+ // If no address was specified, send a broadcast on each interface
+ if (not _hint.has_key("addr")) {
+ for (const if_addrs_t& if_addrs : get_if_addrs()) {
+ // avoid the loopback device
+ if (if_addrs.inet == asio::ip::address_v4::loopback().to_string())
+ continue;
- //create a new hint with this broadcast address
+ // create a new hint with this broadcast address
device_addr_t new_hint = hint;
- new_hint["addr"] = if_addrs.bcast;
+ new_hint["addr"] = if_addrs.bcast;
- //call discover with the new hint and append results
+ // call discover with the new hint and append results
device_addrs_t new_octoclock_addrs = octoclock_find(new_hint);
octoclock_addrs.insert(octoclock_addrs.begin(),
- new_octoclock_addrs.begin(), new_octoclock_addrs.end()
- );
+ new_octoclock_addrs.begin(),
+ new_octoclock_addrs.end());
}
return octoclock_addrs;
}
- //Create a UDP transport to communicate
+ // Create a UDP transport to communicate
udp_simple::sptr udp_transport = udp_simple::make_broadcast(
- _hint["addr"],
- BOOST_STRINGIZE(OCTOCLOCK_UDP_CTRL_PORT)
- );
+ _hint["addr"], BOOST_STRINGIZE(OCTOCLOCK_UDP_CTRL_PORT));
- //Send a query packet
+ // Send a query packet
octoclock_packet_t pkt_out;
pkt_out.proto_ver = OCTOCLOCK_FW_COMPAT_NUM;
// To avoid replicating sequence numbers between sessions
pkt_out.sequence = uint32_t(std::rand());
- pkt_out.len = 0;
- pkt_out.code = OCTOCLOCK_QUERY_CMD;
- try{
+ pkt_out.len = 0;
+ pkt_out.code = OCTOCLOCK_QUERY_CMD;
+ try {
udp_transport->send(boost::asio::buffer(&pkt_out, sizeof(pkt_out)));
- }
- catch(const std::exception &ex){
- UHD_LOGGER_ERROR("OCTOCLOCK") << "OctoClock network discovery error - " << ex.what() ;
- }
- catch(...){
- UHD_LOGGER_ERROR("OCTOCLOCK") << "OctoClock network discovery unknown error" ;
+ } catch (const std::exception& ex) {
+ UHD_LOGGER_ERROR("OCTOCLOCK")
+ << "OctoClock network discovery error - " << ex.what();
+ } catch (...) {
+ UHD_LOGGER_ERROR("OCTOCLOCK") << "OctoClock network discovery unknown error";
}
uint8_t octoclock_data[udp_simple::mtu];
- const octoclock_packet_t *pkt_in = reinterpret_cast<octoclock_packet_t*>(octoclock_data);
+ const octoclock_packet_t* pkt_in =
+ reinterpret_cast<octoclock_packet_t*>(octoclock_data);
- while(true){
+ while (true) {
size_t len = udp_transport->recv(asio::buffer(octoclock_data));
- if(UHD_OCTOCLOCK_PACKET_MATCHES(OCTOCLOCK_QUERY_ACK, pkt_out, pkt_in, len)){
+ if (UHD_OCTOCLOCK_PACKET_MATCHES(OCTOCLOCK_QUERY_ACK, pkt_out, pkt_in, len)) {
device_addr_t new_addr;
new_addr["addr"] = udp_transport->get_recv_addr();
- //Attempt direct communication with OctoClock
+ // Attempt direct communication with OctoClock
udp_simple::sptr ctrl_xport = udp_simple::make_connected(
- new_addr["addr"],
- BOOST_STRINGIZE(OCTOCLOCK_UDP_CTRL_PORT)
- );
- UHD_OCTOCLOCK_SEND_AND_RECV(ctrl_xport, OCTOCLOCK_FW_COMPAT_NUM, OCTOCLOCK_QUERY_CMD, pkt_out, len, octoclock_data);
- if(UHD_OCTOCLOCK_PACKET_MATCHES(OCTOCLOCK_QUERY_ACK, pkt_out, pkt_in, len)){
- //If the OctoClock is in its bootloader, don't ask for details
- if(pkt_in->proto_ver == OCTOCLOCK_BOOTLOADER_PROTO_VER){
+ new_addr["addr"], BOOST_STRINGIZE(OCTOCLOCK_UDP_CTRL_PORT));
+ UHD_OCTOCLOCK_SEND_AND_RECV(ctrl_xport,
+ OCTOCLOCK_FW_COMPAT_NUM,
+ OCTOCLOCK_QUERY_CMD,
+ pkt_out,
+ len,
+ octoclock_data);
+ if (UHD_OCTOCLOCK_PACKET_MATCHES(OCTOCLOCK_QUERY_ACK, pkt_out, pkt_in, len)) {
+ // If the OctoClock is in its bootloader, don't ask for details
+ if (pkt_in->proto_ver == OCTOCLOCK_BOOTLOADER_PROTO_VER) {
new_addr["type"] = "octoclock-bootloader";
octoclock_addrs.push_back(new_addr);
- }
- else {
+ } else {
new_addr["type"] = "octoclock";
- if(pkt_in->proto_ver >= OCTOCLOCK_FW_MIN_COMPAT_NUM and pkt_in->proto_ver <= OCTOCLOCK_FW_COMPAT_NUM) {
+ if (pkt_in->proto_ver >= OCTOCLOCK_FW_MIN_COMPAT_NUM
+ and pkt_in->proto_ver <= OCTOCLOCK_FW_COMPAT_NUM) {
octoclock_eeprom_t oc_eeprom(ctrl_xport, pkt_in->proto_ver);
- new_addr["name"] = oc_eeprom["name"];
+ new_addr["name"] = oc_eeprom["name"];
new_addr["serial"] = oc_eeprom["serial"];
} else {
- new_addr["name"] = "";
+ new_addr["name"] = "";
new_addr["serial"] = "";
}
- //Filter based on optional keys (if any)
- if(
- (not _hint.has_key("name") or (_hint["name"] == new_addr["name"])) and
- (not _hint.has_key("serial") or (_hint["serial"] == new_addr["serial"]))
- ){
+ // Filter based on optional keys (if any)
+ if ((not _hint.has_key("name") or (_hint["name"] == new_addr["name"]))
+ and (not _hint.has_key("serial")
+ or (_hint["serial"] == new_addr["serial"]))) {
octoclock_addrs.push_back(new_addr);
}
}
- }
- else continue;
+ } else
+ continue;
}
- if(len == 0) break;
+ if (len == 0)
+ break;
}
return octoclock_addrs;
}
-device::sptr octoclock_make(const device_addr_t &device_addr){
+device::sptr octoclock_make(const device_addr_t& device_addr)
+{
return device::sptr(new octoclock_impl(device_addr));
}
-UHD_STATIC_BLOCK(register_octoclock_device){
+UHD_STATIC_BLOCK(register_octoclock_device)
+{
device::register_device(&octoclock_find, &octoclock_make, device::CLOCK);
}
/***********************************************************************
* Structors
**********************************************************************/
-octoclock_impl::octoclock_impl(const device_addr_t &_device_addr){
+octoclock_impl::octoclock_impl(const device_addr_t& _device_addr)
+{
UHD_LOGGER_INFO("OCTOCLOCK") << "Opening an OctoClock device...";
- _type = device::CLOCK;
+ _type = device::CLOCK;
device_addrs_t device_args = separate_device_addr(_device_addr);
// To avoid replicating sequence numbers between sessions
_sequence = uint32_t(std::rand());
@@ -182,17 +196,19 @@ octoclock_impl::octoclock_impl(const device_addr_t &_device_addr){
_tree = property_tree::make();
_tree->create<std::string>("/name").set("OctoClock Device");
- for(size_t oci = 0; oci < device_args.size(); oci++){
+ for (size_t oci = 0; oci < device_args.size(); oci++) {
const device_addr_t device_args_i = device_args[oci];
- const std::string addr = device_args_i["addr"];
- //Can't make a device out of an OctoClock in bootloader state
- if(device_args_i["type"] == "octoclock-bootloader"){
- throw uhd::runtime_error(str(boost::format(
- "\n\nThis device is in its bootloader state and cannot be used by UHD.\n"
- "This may mean the firmware on the device has been corrupted and will\n"
- "need to be burned again.\n\n"
- "%s\n"
- ) % _get_images_help_message(addr)));
+ const std::string addr = device_args_i["addr"];
+ // Can't make a device out of an OctoClock in bootloader state
+ if (device_args_i["type"] == "octoclock-bootloader") {
+ throw uhd::runtime_error(
+ str(boost::format("\n\nThis device is in its bootloader state and cannot "
+ "be used by UHD.\n"
+ "This may mean the firmware on the device has been "
+ "corrupted and will\n"
+ "need to be burned again.\n\n"
+ "%s\n")
+ % _get_images_help_message(addr)));
}
const std::string oc = std::to_string(oci);
@@ -200,8 +216,10 @@ octoclock_impl::octoclock_impl(const device_addr_t &_device_addr){
////////////////////////////////////////////////////////////////////
// Set up UDP transports
////////////////////////////////////////////////////////////////////
- _oc_dict[oc].ctrl_xport = udp_simple::make_connected(addr, BOOST_STRINGIZE(OCTOCLOCK_UDP_CTRL_PORT));
- _oc_dict[oc].gpsdo_xport = udp_simple::make_connected(addr, BOOST_STRINGIZE(OCTOCLOCK_UDP_GPSDO_PORT));
+ _oc_dict[oc].ctrl_xport =
+ udp_simple::make_connected(addr, BOOST_STRINGIZE(OCTOCLOCK_UDP_CTRL_PORT));
+ _oc_dict[oc].gpsdo_xport =
+ udp_simple::make_connected(addr, BOOST_STRINGIZE(OCTOCLOCK_UDP_GPSDO_PORT));
const fs_path oc_path = "/mboards/" + oc;
_tree->create<std::string>(oc_path / "name").set("OctoClock");
@@ -210,15 +228,19 @@ octoclock_impl::octoclock_impl(const device_addr_t &_device_addr){
// Check the firmware compatibility number
////////////////////////////////////////////////////////////////////
_proto_ver = _get_fw_version(oc);
- if(_proto_ver < OCTOCLOCK_FW_MIN_COMPAT_NUM or _proto_ver > OCTOCLOCK_FW_COMPAT_NUM){
- throw uhd::runtime_error(str(boost::format(
+ if (_proto_ver < OCTOCLOCK_FW_MIN_COMPAT_NUM
+ or _proto_ver > OCTOCLOCK_FW_COMPAT_NUM) {
+ throw uhd::runtime_error(str(
+ boost::format(
"\n\nPlease update your OctoClock's firmware.\n"
"Expected firmware compatibility number %d, but got %d:\n"
"The firmware build is not compatible with the host code build.\n\n"
- "%s\n"
- ) % int(OCTOCLOCK_FW_COMPAT_NUM) % int(_proto_ver) % _get_images_help_message(addr)));
+ "%s\n")
+ % int(OCTOCLOCK_FW_COMPAT_NUM) % int(_proto_ver)
+ % _get_images_help_message(addr)));
}
- _tree->create<std::string>(oc_path / "fw_version").set(std::to_string(int(_proto_ver)));
+ _tree->create<std::string>(oc_path / "fw_version")
+ .set(std::to_string(int(_proto_ver)));
////////////////////////////////////////////////////////////////////
// Set up EEPROM
@@ -226,7 +248,8 @@ octoclock_impl::octoclock_impl(const device_addr_t &_device_addr){
_oc_dict[oc].eeprom = octoclock_eeprom_t(_oc_dict[oc].ctrl_xport, _proto_ver);
_tree->create<octoclock_eeprom_t>(oc_path / "eeprom")
.set(_oc_dict[oc].eeprom)
- .add_coerced_subscriber(std::bind(&octoclock_impl::_set_eeprom, this, oc, std::placeholders::_1));
+ .add_coerced_subscriber(
+ std::bind(&octoclock_impl::_set_eeprom, this, oc, std::placeholders::_1));
////////////////////////////////////////////////////////////////////
// Initialize non-GPSDO sensors
@@ -247,178 +270,215 @@ octoclock_impl::octoclock_impl(const device_addr_t &_device_addr){
////////////////////////////////////////////////////////////////////
std::string asterisk = (device_args.size() > 1) ? " * " : "";
- if(device_args.size() > 1){
+ if (device_args.size() > 1) {
UHD_LOGGER_INFO("OCTOCLOCK") << "Checking status of " << addr;
}
- UHD_LOGGER_INFO("OCTOCLOCK") << boost::format("%sDetecting internal GPSDO...") % asterisk;
+ UHD_LOGGER_INFO("OCTOCLOCK")
+ << boost::format("%sDetecting internal GPSDO...") % asterisk;
_get_state(oc);
- if(_oc_dict[oc].state.gps_detected){
- try{
- _oc_dict[oc].gps = gps_ctrl::make(octoclock_make_uart_iface(_oc_dict[oc].gpsdo_xport, _proto_ver));
+ if (_oc_dict[oc].state.gps_detected) {
+ try {
+ _oc_dict[oc].gps = gps_ctrl::make(
+ octoclock_make_uart_iface(_oc_dict[oc].gpsdo_xport, _proto_ver));
- if(_oc_dict[oc].gps and _oc_dict[oc].gps->gps_detected()){
- for(const std::string &name: _oc_dict[oc].gps->get_sensors()){
+ if (_oc_dict[oc].gps and _oc_dict[oc].gps->gps_detected()) {
+ for (const std::string& name : _oc_dict[oc].gps->get_sensors()) {
_tree->create<sensor_value_t>(oc_path / "sensors" / name)
- .set_publisher(std::bind(&gps_ctrl::get_sensor, _oc_dict[oc].gps, name));
+ .set_publisher(
+ std::bind(&gps_ctrl::get_sensor, _oc_dict[oc].gps, name));
}
- }
- else{
- //If GPSDO communication failed, set gps_detected to false
+ } else {
+ // If GPSDO communication failed, set gps_detected to false
_oc_dict[oc].state.gps_detected = 0;
- UHD_LOGGER_WARNING("OCTOCLOCK") << "Device reports that it has a GPSDO, but we cannot communicate with it.";
+ UHD_LOGGER_WARNING("OCTOCLOCK")
+ << "Device reports that it has a GPSDO, but we cannot "
+ "communicate with it.";
}
+ } catch (std::exception& e) {
+ UHD_LOGGER_ERROR("OCTOCLOCK")
+ << "An error occurred making GPSDO control: " << e.what();
}
- catch(std::exception &e){
- UHD_LOGGER_ERROR("OCTOCLOCK") << "An error occurred making GPSDO control: " << e.what();
- }
- }
- else UHD_LOGGER_INFO("OCTOCLOCK") << "No GPSDO found";
- UHD_LOGGER_INFO("OCTOCLOCK") << boost::format("%sDetecting external reference...%s") % asterisk
- % _ext_ref_detected(oc).value;
- UHD_LOGGER_INFO("OCTOCLOCK") << boost::format("%sDetecting switch position...%s") % asterisk
- % _switch_pos(oc).value;
+ } else
+ UHD_LOGGER_INFO("OCTOCLOCK") << "No GPSDO found";
+ UHD_LOGGER_INFO("OCTOCLOCK")
+ << boost::format("%sDetecting external reference...%s") % asterisk
+ % _ext_ref_detected(oc).value;
+ UHD_LOGGER_INFO("OCTOCLOCK") << boost::format("%sDetecting switch position...%s")
+ % asterisk % _switch_pos(oc).value;
std::string ref = _which_ref(oc).value;
- if(ref == "none") UHD_LOGGER_INFO("OCTOCLOCK") << boost::format("%sDevice is not using any reference") % asterisk;
- else UHD_LOGGER_INFO("OCTOCLOCK") << boost::format("%sDevice is using %s reference") % asterisk
- % _which_ref(oc).value
- ;
+ if (ref == "none")
+ UHD_LOGGER_INFO("OCTOCLOCK")
+ << boost::format("%sDevice is not using any reference") % asterisk;
+ else
+ UHD_LOGGER_INFO("OCTOCLOCK")
+ << boost::format("%sDevice is using %s reference") % asterisk
+ % _which_ref(oc).value;
}
}
-rx_streamer::sptr octoclock_impl::get_rx_stream(UHD_UNUSED(const stream_args_t &args)){
+rx_streamer::sptr octoclock_impl::get_rx_stream(UHD_UNUSED(const stream_args_t& args))
+{
throw uhd::not_implemented_error("This function is incompatible with this device.");
}
-tx_streamer::sptr octoclock_impl::get_tx_stream(UHD_UNUSED(const stream_args_t &args)){
+tx_streamer::sptr octoclock_impl::get_tx_stream(UHD_UNUSED(const stream_args_t& args))
+{
throw uhd::not_implemented_error("This function is incompatible with this device.");
}
-bool octoclock_impl::recv_async_msg(UHD_UNUSED(uhd::async_metadata_t&), UHD_UNUSED(double)){
+bool octoclock_impl::recv_async_msg(
+ UHD_UNUSED(uhd::async_metadata_t&), UHD_UNUSED(double))
+{
throw uhd::not_implemented_error("This function is incompatible with this device.");
}
-void octoclock_impl::_set_eeprom(const std::string &oc, const octoclock_eeprom_t &oc_eeprom){
+void octoclock_impl::_set_eeprom(
+ const std::string& oc, const octoclock_eeprom_t& oc_eeprom)
+{
/*
* The OctoClock needs a full octoclock_eeprom_t so as to not erase
* what it currently has in the EEPROM, so store the relevant values
* from the user's input and send that instead.
*/
- for(const std::string &key: oc_eeprom.keys()){
- if(_oc_dict[oc].eeprom.has_key(key)) _oc_dict[oc].eeprom[key] = oc_eeprom[key];
+ for (const std::string& key : oc_eeprom.keys()) {
+ if (_oc_dict[oc].eeprom.has_key(key))
+ _oc_dict[oc].eeprom[key] = oc_eeprom[key];
}
_oc_dict[oc].eeprom.commit();
}
-uint32_t octoclock_impl::_get_fw_version(const std::string &oc){
+uint32_t octoclock_impl::_get_fw_version(const std::string& oc)
+{
octoclock_packet_t pkt_out;
pkt_out.sequence = uhd::htonx<uint32_t>(++_sequence);
- pkt_out.len = 0;
+ pkt_out.len = 0;
size_t len;
uint8_t octoclock_data[udp_simple::mtu];
- const octoclock_packet_t *pkt_in = reinterpret_cast<octoclock_packet_t*>(octoclock_data);
-
- UHD_OCTOCLOCK_SEND_AND_RECV(_oc_dict[oc].ctrl_xport, OCTOCLOCK_FW_COMPAT_NUM, OCTOCLOCK_QUERY_CMD, pkt_out, len, octoclock_data);
- if(UHD_OCTOCLOCK_PACKET_MATCHES(OCTOCLOCK_QUERY_ACK, pkt_out, pkt_in, len)){
+ const octoclock_packet_t* pkt_in =
+ reinterpret_cast<octoclock_packet_t*>(octoclock_data);
+
+ UHD_OCTOCLOCK_SEND_AND_RECV(_oc_dict[oc].ctrl_xport,
+ OCTOCLOCK_FW_COMPAT_NUM,
+ OCTOCLOCK_QUERY_CMD,
+ pkt_out,
+ len,
+ octoclock_data);
+ if (UHD_OCTOCLOCK_PACKET_MATCHES(OCTOCLOCK_QUERY_ACK, pkt_out, pkt_in, len)) {
return pkt_in->proto_ver;
- }
- else throw uhd::runtime_error("Failed to retrieve firmware version from OctoClock.");
+ } else
+ throw uhd::runtime_error("Failed to retrieve firmware version from OctoClock.");
}
-void octoclock_impl::_get_state(const std::string &oc){
+void octoclock_impl::_get_state(const std::string& oc)
+{
octoclock_packet_t pkt_out;
pkt_out.sequence = uhd::htonx<uint32_t>(++_sequence);
- pkt_out.len = 0;
- size_t len = 0;
+ pkt_out.len = 0;
+ size_t len = 0;
uint8_t octoclock_data[udp_simple::mtu];
- const octoclock_packet_t *pkt_in = reinterpret_cast<octoclock_packet_t*>(octoclock_data);
-
- UHD_OCTOCLOCK_SEND_AND_RECV(_oc_dict[oc].ctrl_xport, _proto_ver, SEND_STATE_CMD, pkt_out, len, octoclock_data);
- if(UHD_OCTOCLOCK_PACKET_MATCHES(SEND_STATE_ACK, pkt_out, pkt_in, len)){
- const octoclock_state_t *state = reinterpret_cast<const octoclock_state_t*>(pkt_in->data);
+ const octoclock_packet_t* pkt_in =
+ reinterpret_cast<octoclock_packet_t*>(octoclock_data);
+
+ UHD_OCTOCLOCK_SEND_AND_RECV(_oc_dict[oc].ctrl_xport,
+ _proto_ver,
+ SEND_STATE_CMD,
+ pkt_out,
+ len,
+ octoclock_data);
+ if (UHD_OCTOCLOCK_PACKET_MATCHES(SEND_STATE_ACK, pkt_out, pkt_in, len)) {
+ const octoclock_state_t* state =
+ reinterpret_cast<const octoclock_state_t*>(pkt_in->data);
_oc_dict[oc].state = *state;
- }
- else throw uhd::runtime_error("Failed to retrieve state information from OctoClock.");
+ } else
+ throw uhd::runtime_error("Failed to retrieve state information from OctoClock.");
}
-uhd::dict<ref_t, std::string> _ref_strings = boost::assign::map_list_of
- (NO_REF, "none")
- (INTERNAL, "internal")
- (EXTERNAL, "external")
-;
+uhd::dict<ref_t, std::string> _ref_strings = boost::assign::map_list_of(NO_REF, "none")(
+ INTERNAL, "internal")(EXTERNAL, "external");
-uhd::dict<switch_pos_t, std::string> _switch_pos_strings = boost::assign::map_list_of
- (PREFER_INTERNAL, "Prefer internal")
- (PREFER_EXTERNAL, "Prefer external")
-;
+uhd::dict<switch_pos_t, std::string> _switch_pos_strings = boost::assign::map_list_of(
+ PREFER_INTERNAL, "Prefer internal")(PREFER_EXTERNAL, "Prefer external");
-sensor_value_t octoclock_impl::_ext_ref_detected(const std::string &oc){
+sensor_value_t octoclock_impl::_ext_ref_detected(const std::string& oc)
+{
_get_state(oc);
- return sensor_value_t("External reference detected", (_oc_dict[oc].state.external_detected > 0),
- "true", "false");
+ return sensor_value_t("External reference detected",
+ (_oc_dict[oc].state.external_detected > 0),
+ "true",
+ "false");
}
-sensor_value_t octoclock_impl::_gps_detected(const std::string &oc){
- //Don't check, this shouldn't change once device is turned on
+sensor_value_t octoclock_impl::_gps_detected(const std::string& oc)
+{
+ // Don't check, this shouldn't change once device is turned on
- return sensor_value_t("GPSDO detected", (_oc_dict[oc].state.gps_detected > 0),
- "true", "false");
+ return sensor_value_t(
+ "GPSDO detected", (_oc_dict[oc].state.gps_detected > 0), "true", "false");
}
-sensor_value_t octoclock_impl::_which_ref(const std::string &oc){
+sensor_value_t octoclock_impl::_which_ref(const std::string& oc)
+{
_get_state(oc);
- if(not _ref_strings.has_key(ref_t(_oc_dict[oc].state.which_ref))){
+ if (not _ref_strings.has_key(ref_t(_oc_dict[oc].state.which_ref))) {
throw uhd::runtime_error("Invalid reference detected.");
}
- return sensor_value_t("Using reference", _ref_strings[ref_t(_oc_dict[oc].state.which_ref)], "");
+ return sensor_value_t(
+ "Using reference", _ref_strings[ref_t(_oc_dict[oc].state.which_ref)], "");
}
-sensor_value_t octoclock_impl::_switch_pos(const std::string &oc){
+sensor_value_t octoclock_impl::_switch_pos(const std::string& oc)
+{
_get_state(oc);
- if(not _switch_pos_strings.has_key(switch_pos_t(_oc_dict[oc].state.switch_pos))){
+ if (not _switch_pos_strings.has_key(switch_pos_t(_oc_dict[oc].state.switch_pos))) {
throw uhd::runtime_error("Invalid switch position detected.");
}
- return sensor_value_t("Switch position", _switch_pos_strings[switch_pos_t(_oc_dict[oc].state.switch_pos)], "");
+ return sensor_value_t("Switch position",
+ _switch_pos_strings[switch_pos_t(_oc_dict[oc].state.switch_pos)],
+ "");
}
-uint32_t octoclock_impl::_get_time(const std::string &oc){
- if(_oc_dict[oc].state.gps_detected){
+uint32_t octoclock_impl::_get_time(const std::string& oc)
+{
+ if (_oc_dict[oc].state.gps_detected) {
std::string time_str = _oc_dict[oc].gps->get_sensor("gps_time").value;
return boost::lexical_cast<uint32_t>(time_str);
- }
- else throw uhd::runtime_error("This device cannot return a time.");
+ } else
+ throw uhd::runtime_error("This device cannot return a time.");
}
-std::string octoclock_impl::_get_images_help_message(const std::string &addr){
+std::string octoclock_impl::_get_images_help_message(const std::string& addr)
+{
const std::string image_name = "octoclock_r4_fw.hex";
- //Check to see if image is in default location
+ // Check to see if image is in default location
std::string image_location;
- try{
+ try {
image_location = uhd::find_image_path(image_name);
- }
- catch(const std::exception &){
+ } catch (const std::exception&) {
return str(boost::format("Could not find %s in your images path.\n%s")
- % image_name
- % uhd::print_utility_error("uhd_images_downloader.py"));
+ % image_name % uhd::print_utility_error("uhd_images_downloader.py"));
}
- //Get escape character
- #ifdef UHD_PLATFORM_WIN32
+// Get escape character
+#ifdef UHD_PLATFORM_WIN32
const std::string ml = "^\n ";
- #else
+#else
const std::string ml = "\\\n ";
- #endif
-
- //Get burner command
- const std::string burner_path = (fs::path(uhd::get_pkg_path()) / "bin" / "uhd_image_loader").string();
- const std::string burner_cmd = str(boost::format("%s %s--addr=\"%s\"") % burner_path % ml % addr);
- return str(boost::format("%s\n%s") % uhd::print_utility_error("uhd_images_downloader.py") % burner_cmd);
+#endif
+
+ // Get burner command
+ const std::string burner_path =
+ (fs::path(uhd::get_pkg_path()) / "bin" / "uhd_image_loader").string();
+ const std::string burner_cmd =
+ str(boost::format("%s %s--addr=\"%s\"") % burner_path % ml % addr);
+ return str(boost::format("%s\n%s")
+ % uhd::print_utility_error("uhd_images_downloader.py") % burner_cmd);
}
diff --git a/host/lib/usrp_clock/octoclock/octoclock_impl.hpp b/host/lib/usrp_clock/octoclock/octoclock_impl.hpp
index 8fcda1999..d293ce3e5 100644
--- a/host/lib/usrp_clock/octoclock/octoclock_impl.hpp
+++ b/host/lib/usrp_clock/octoclock/octoclock_impl.hpp
@@ -8,37 +8,37 @@
#ifndef INCLUDED_OCTOCLOCK_IMPL_HPP
#define INCLUDED_OCTOCLOCK_IMPL_HPP
-#include <memory>
-#include <boost/thread.hpp>
-
+#include "common.h"
#include <uhd/device.hpp>
#include <uhd/stream.hpp>
-#include <uhd/usrp/gps_ctrl.hpp>
-#include <uhd/usrp_clock/octoclock_eeprom.hpp>
#include <uhd/types/device_addr.hpp>
#include <uhd/types/dict.hpp>
#include <uhd/types/sensors.hpp>
+#include <uhd/usrp/gps_ctrl.hpp>
+#include <uhd/usrp_clock/octoclock_eeprom.hpp>
+#include <boost/thread.hpp>
+#include <memory>
-#include "common.h"
-
-uhd::device_addrs_t octoclock_find(const uhd::device_addr_t &hint);
+uhd::device_addrs_t octoclock_find(const uhd::device_addr_t& hint);
/*!
* OctoClock implementation guts
*/
-class octoclock_impl : public uhd::device{
+class octoclock_impl : public uhd::device
+{
public:
- octoclock_impl(const uhd::device_addr_t &);
- ~octoclock_impl(void) {};
+ octoclock_impl(const uhd::device_addr_t&);
+ ~octoclock_impl(void){};
- uhd::rx_streamer::sptr get_rx_stream(const uhd::stream_args_t &args);
+ uhd::rx_streamer::sptr get_rx_stream(const uhd::stream_args_t& args);
- uhd::tx_streamer::sptr get_tx_stream(const uhd::stream_args_t &args);
+ uhd::tx_streamer::sptr get_tx_stream(const uhd::stream_args_t& args);
bool recv_async_msg(uhd::async_metadata_t&, double);
private:
- struct oc_container_type{
+ struct oc_container_type
+ {
uhd::usrp_clock::octoclock_eeprom_t eeprom;
octoclock_state_t state;
uhd::transport::udp_simple::sptr ctrl_xport;
@@ -47,25 +47,26 @@ private:
};
uhd::dict<std::string, oc_container_type> _oc_dict;
uint32_t _sequence;
- uint32_t _proto_ver;
+ uint32_t _proto_ver;
- void _set_eeprom(const std::string &oc, const uhd::usrp_clock::octoclock_eeprom_t &oc_eeprom);
+ void _set_eeprom(
+ const std::string& oc, const uhd::usrp_clock::octoclock_eeprom_t& oc_eeprom);
- uint32_t _get_fw_version(const std::string &oc);
+ uint32_t _get_fw_version(const std::string& oc);
- void _get_state(const std::string &oc);
+ void _get_state(const std::string& oc);
- uhd::sensor_value_t _ext_ref_detected(const std::string &oc);
+ uhd::sensor_value_t _ext_ref_detected(const std::string& oc);
- uhd::sensor_value_t _gps_detected(const std::string &oc);
+ uhd::sensor_value_t _gps_detected(const std::string& oc);
- uhd::sensor_value_t _which_ref(const std::string &oc);
+ uhd::sensor_value_t _which_ref(const std::string& oc);
- uhd::sensor_value_t _switch_pos(const std::string &oc);
+ uhd::sensor_value_t _switch_pos(const std::string& oc);
- uint32_t _get_time(const std::string &oc);
+ uint32_t _get_time(const std::string& oc);
- std::string _get_images_help_message(const std::string &addr);
+ std::string _get_images_help_message(const std::string& addr);
boost::mutex _device_mutex;
};
diff --git a/host/lib/usrp_clock/octoclock/octoclock_uart.cpp b/host/lib/usrp_clock/octoclock/octoclock_uart.cpp
index 7fc455dda..15c503888 100644
--- a/host/lib/usrp_clock/octoclock/octoclock_uart.cpp
+++ b/host/lib/usrp_clock/octoclock/octoclock_uart.cpp
@@ -5,163 +5,173 @@
// SPDX-License-Identifier: GPL-3.0-or-later
//
-#include <iostream>
-#include <string>
-#include <chrono>
-#include <thread>
-#include <string.h>
+#include "octoclock_uart.hpp"
+#include "common.h"
+#include <uhd/exception.hpp>
+#include <uhd/utils/byteswap.hpp>
#include <stdint.h>
-
+#include <string.h>
#include <boost/algorithm/string.hpp>
#include <boost/asio.hpp>
#include <boost/format.hpp>
#include <boost/thread/thread.hpp>
-
-#include <uhd/exception.hpp>
-#include <uhd/utils/byteswap.hpp>
-
-#include "common.h"
-#include "octoclock_uart.hpp"
+#include <chrono>
+#include <string>
+#include <thread>
namespace asio = boost::asio;
using namespace uhd::transport;
-#define NUM_WRAPS_EQUAL (_state.num_wraps == _device_state.num_wraps)
-#define POS_EQUAL (_state.pos == _device_state.pos)
-#define STATES_EQUAL (NUM_WRAPS_EQUAL && POS_EQUAL)
-#define MAX_CACHE_AGE 256 //seconds
-
-namespace uhd{
- octoclock_uart_iface::octoclock_uart_iface(udp_simple::sptr udp, uint32_t proto_ver): uart_iface(){
- _udp = udp;
- _state.num_wraps = 0;
- _state.pos = 0;
- _device_state.num_wraps = 0;
- _device_state.pos = 0;
- _proto_ver = proto_ver;
- // To avoid replicating sequence numbers between sessions
- _sequence = uint32_t(std::rand());
- size_t len = 0;
-
- //Get pool size from device
- octoclock_packet_t pkt_out;
- pkt_out.sequence = uhd::htonx<uint32_t>(_sequence);
- pkt_out.len = 0;
-
- uint8_t octoclock_data[udp_simple::mtu];
- const octoclock_packet_t *pkt_in = reinterpret_cast<octoclock_packet_t*>(octoclock_data);
-
- UHD_OCTOCLOCK_SEND_AND_RECV(_udp, _proto_ver, SEND_POOLSIZE_CMD, pkt_out, len, octoclock_data);
- if(UHD_OCTOCLOCK_PACKET_MATCHES(SEND_POOLSIZE_ACK, pkt_out, pkt_in, len)){
- _poolsize = pkt_in->poolsize;
- _cache.resize(_poolsize);
- }
- else throw uhd::runtime_error("Failed to communicate with GPSDO.");
- }
+#define NUM_WRAPS_EQUAL (_state.num_wraps == _device_state.num_wraps)
+#define POS_EQUAL (_state.pos == _device_state.pos)
+#define STATES_EQUAL (NUM_WRAPS_EQUAL && POS_EQUAL)
+#define MAX_CACHE_AGE 256 // seconds
+
+namespace uhd {
+octoclock_uart_iface::octoclock_uart_iface(udp_simple::sptr udp, uint32_t proto_ver)
+ : uart_iface()
+{
+ _udp = udp;
+ _state.num_wraps = 0;
+ _state.pos = 0;
+ _device_state.num_wraps = 0;
+ _device_state.pos = 0;
+ _proto_ver = proto_ver;
+ // To avoid replicating sequence numbers between sessions
+ _sequence = uint32_t(std::rand());
+ size_t len = 0;
+
+ // Get pool size from device
+ octoclock_packet_t pkt_out;
+ pkt_out.sequence = uhd::htonx<uint32_t>(_sequence);
+ pkt_out.len = 0;
+
+ uint8_t octoclock_data[udp_simple::mtu];
+ const octoclock_packet_t* pkt_in =
+ reinterpret_cast<octoclock_packet_t*>(octoclock_data);
+
+ UHD_OCTOCLOCK_SEND_AND_RECV(
+ _udp, _proto_ver, SEND_POOLSIZE_CMD, pkt_out, len, octoclock_data);
+ if (UHD_OCTOCLOCK_PACKET_MATCHES(SEND_POOLSIZE_ACK, pkt_out, pkt_in, len)) {
+ _poolsize = pkt_in->poolsize;
+ _cache.resize(_poolsize);
+ } else
+ throw uhd::runtime_error("Failed to communicate with GPSDO.");
+}
- void octoclock_uart_iface::write_uart(const std::string &buf){
- size_t len = 0;
+void octoclock_uart_iface::write_uart(const std::string& buf)
+{
+ size_t len = 0;
- octoclock_packet_t pkt_out;
- pkt_out.sequence = uhd::htonx<uint32_t>(++_sequence);
- pkt_out.len = buf.size();
- memcpy(pkt_out.data, buf.c_str(), buf.size());
+ octoclock_packet_t pkt_out;
+ pkt_out.sequence = uhd::htonx<uint32_t>(++_sequence);
+ pkt_out.len = buf.size();
+ memcpy(pkt_out.data, buf.c_str(), buf.size());
- uint8_t octoclock_data[udp_simple::mtu];
- const octoclock_packet_t *pkt_in = reinterpret_cast<octoclock_packet_t*>(octoclock_data);
+ uint8_t octoclock_data[udp_simple::mtu];
+ const octoclock_packet_t* pkt_in =
+ reinterpret_cast<octoclock_packet_t*>(octoclock_data);
- UHD_OCTOCLOCK_SEND_AND_RECV(_udp, _proto_ver, HOST_SEND_TO_GPSDO_CMD, pkt_out, len, octoclock_data);
- if(not UHD_OCTOCLOCK_PACKET_MATCHES(HOST_SEND_TO_GPSDO_ACK, pkt_out, pkt_in, len)){
- throw uhd::runtime_error("Failed to send commands to GPSDO.");
- }
+ UHD_OCTOCLOCK_SEND_AND_RECV(
+ _udp, _proto_ver, HOST_SEND_TO_GPSDO_CMD, pkt_out, len, octoclock_data);
+ if (not UHD_OCTOCLOCK_PACKET_MATCHES(HOST_SEND_TO_GPSDO_ACK, pkt_out, pkt_in, len)) {
+ throw uhd::runtime_error("Failed to send commands to GPSDO.");
}
+}
- std::string octoclock_uart_iface::read_uart(double timeout){
- std::string result;
- const auto exit_time =
- std::chrono::steady_clock::now()
- + std::chrono::milliseconds(int64_t(timeout*1e3));
+std::string octoclock_uart_iface::read_uart(double timeout)
+{
+ std::string result;
+ const auto exit_time = std::chrono::steady_clock::now()
+ + std::chrono::milliseconds(int64_t(timeout * 1e3));
- while(true)
- {
- _update_cache();
+ while (true) {
+ _update_cache();
- for(char ch = _getchar(); ch != 0; ch = _getchar()){
- _rxbuff += ch;
+ for (char ch = _getchar(); ch != 0; ch = _getchar()) {
+ _rxbuff += ch;
- //If newline found, return string
- if(ch == '\n'){
- result.swap(_rxbuff);
- return result;
- }
+ // If newline found, return string
+ if (ch == '\n') {
+ result.swap(_rxbuff);
+ return result;
}
- if (std::chrono::steady_clock::now() > exit_time) {
- break;
- }
- std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
-
- return result;
+ if (std::chrono::steady_clock::now() > exit_time) {
+ break;
+ }
+ std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
- void octoclock_uart_iface::_update_cache(){
- octoclock_packet_t pkt_out;
- pkt_out.len = 0;
- size_t len = 0;
-
- uint8_t octoclock_data[udp_simple::mtu];
- const octoclock_packet_t *pkt_in = reinterpret_cast<octoclock_packet_t*>(octoclock_data);
-
- if(STATES_EQUAL){
- boost::system_time time = boost::get_system_time();
- boost::posix_time::time_duration age = time - _last_cache_update;
- bool cache_expired = (age > boost::posix_time::seconds(MAX_CACHE_AGE));
-
- pkt_out.sequence = uhd::htonx<uint32_t>(++_sequence);
- UHD_OCTOCLOCK_SEND_AND_RECV(_udp, _proto_ver, SEND_GPSDO_CACHE_CMD, pkt_out, len, octoclock_data);
- if(UHD_OCTOCLOCK_PACKET_MATCHES(SEND_GPSDO_CACHE_ACK, pkt_out, pkt_in, len)){
- memcpy(&_cache[0], pkt_in->data, _poolsize);
- _device_state = pkt_in->state;
- _last_cache_update = time;
- }
+ return result;
+}
+
+void octoclock_uart_iface::_update_cache()
+{
+ octoclock_packet_t pkt_out;
+ pkt_out.len = 0;
+ size_t len = 0;
+
+ uint8_t octoclock_data[udp_simple::mtu];
+ const octoclock_packet_t* pkt_in =
+ reinterpret_cast<octoclock_packet_t*>(octoclock_data);
+
+ if (STATES_EQUAL) {
+ boost::system_time time = boost::get_system_time();
+ boost::posix_time::time_duration age = time - _last_cache_update;
+ bool cache_expired = (age > boost::posix_time::seconds(MAX_CACHE_AGE));
- uint8_t delta_wraps = (_device_state.num_wraps - _state.num_wraps);
- if(cache_expired or delta_wraps > 1 or
- ((delta_wraps == 1) and (_device_state.pos > _state.pos))){
-
- _state.pos = _device_state.pos;
- _state.num_wraps = (_device_state.num_wraps-1);
- _rxbuff.clear();
-
- while((_cache[_state.pos] != '\n')){
- _state.pos = (_state.pos+1) % _poolsize;
- //We may have wrapped around locally
- if(_state.pos == 0) _state.num_wraps++;
- if(STATES_EQUAL) break;
- }
- if (_cache[_state.pos] == '\n'){
- _state.pos = (_state.pos+1) % _poolsize;
- //We may have wrapped around locally
- if(_state.pos == 0) _state.num_wraps++;
- }
+ pkt_out.sequence = uhd::htonx<uint32_t>(++_sequence);
+ UHD_OCTOCLOCK_SEND_AND_RECV(
+ _udp, _proto_ver, SEND_GPSDO_CACHE_CMD, pkt_out, len, octoclock_data);
+ if (UHD_OCTOCLOCK_PACKET_MATCHES(SEND_GPSDO_CACHE_ACK, pkt_out, pkt_in, len)) {
+ memcpy(&_cache[0], pkt_in->data, _poolsize);
+ _device_state = pkt_in->state;
+ _last_cache_update = time;
+ }
+
+ uint8_t delta_wraps = (_device_state.num_wraps - _state.num_wraps);
+ if (cache_expired or delta_wraps > 1
+ or ((delta_wraps == 1) and (_device_state.pos > _state.pos))) {
+ _state.pos = _device_state.pos;
+ _state.num_wraps = (_device_state.num_wraps - 1);
+ _rxbuff.clear();
+
+ while ((_cache[_state.pos] != '\n')) {
+ _state.pos = (_state.pos + 1) % _poolsize;
+ // We may have wrapped around locally
+ if (_state.pos == 0)
+ _state.num_wraps++;
+ if (STATES_EQUAL)
+ break;
+ }
+ if (_cache[_state.pos] == '\n') {
+ _state.pos = (_state.pos + 1) % _poolsize;
+ // We may have wrapped around locally
+ if (_state.pos == 0)
+ _state.num_wraps++;
}
}
}
+}
- char octoclock_uart_iface::_getchar(){
- if(STATES_EQUAL){
- return 0;
- }
+char octoclock_uart_iface::_getchar()
+{
+ if (STATES_EQUAL) {
+ return 0;
+ }
- char ch = _cache[_state.pos];
- _state.pos = ((_state.pos+1) % _poolsize);
- //We may have wrapped around locally
- if(_state.pos == 0) _state.num_wraps++;
+ char ch = _cache[_state.pos];
+ _state.pos = ((_state.pos + 1) % _poolsize);
+ // We may have wrapped around locally
+ if (_state.pos == 0)
+ _state.num_wraps++;
- return ch;
- }
+ return ch;
+}
- uart_iface::sptr octoclock_make_uart_iface(udp_simple::sptr udp, uint32_t proto_ver){
- return uart_iface::sptr(new octoclock_uart_iface(udp, proto_ver));
- }
+uart_iface::sptr octoclock_make_uart_iface(udp_simple::sptr udp, uint32_t proto_ver)
+{
+ return uart_iface::sptr(new octoclock_uart_iface(udp, proto_ver));
}
+} // namespace uhd
diff --git a/host/lib/usrp_clock/octoclock/octoclock_uart.hpp b/host/lib/usrp_clock/octoclock/octoclock_uart.hpp
index cb0f58591..02fcf25e3 100644
--- a/host/lib/usrp_clock/octoclock/octoclock_uart.hpp
+++ b/host/lib/usrp_clock/octoclock/octoclock_uart.hpp
@@ -8,23 +8,26 @@
#ifndef INCLUDED_OCTOCLOCK_UART_HPP
#define INCLUDED_OCTOCLOCK_UART_HPP
-#include <vector>
-
+#include "common.h"
#include <uhd/transport/udp_simple.hpp>
#include <uhd/types/serial.hpp>
+#include <boost/thread.hpp>
+#include <string>
+#include <vector>
/*!
* The OctoClock doesn't take UART input per se but reads a specific
* packet type and sends the string from there through its own serial
* functions.
*/
-namespace uhd{
-class octoclock_uart_iface : public uhd::uart_iface{
+namespace uhd {
+class octoclock_uart_iface : public uhd::uart_iface
+{
public:
octoclock_uart_iface(uhd::transport::udp_simple::sptr udp, uint32_t proto_ver);
- ~octoclock_uart_iface(void) {};
+ ~octoclock_uart_iface(void){};
- void write_uart(const std::string &buf);
+ void write_uart(const std::string& buf);
std::string read_uart(double timeout);
private:
@@ -36,15 +39,16 @@ private:
std::vector<uint8_t> _cache;
std::string _rxbuff;
uint32_t _sequence;
- uint32_t _proto_ver;
+ uint32_t _proto_ver;
boost::system_time _last_cache_update;
void _update_cache();
char _getchar();
};
-uart_iface::sptr octoclock_make_uart_iface(uhd::transport::udp_simple::sptr udp, uint32_t proto_ver);
+uart_iface::sptr octoclock_make_uart_iface(
+ uhd::transport::udp_simple::sptr udp, uint32_t proto_ver);
-}
+} // namespace uhd
#endif /* INCLUDED_OCTOCLOCK_UART_HPP */
diff --git a/host/lib/usrp_clock/usrp_clock_c.cpp b/host/lib/usrp_clock/usrp_clock_c.cpp
index 56a9a8740..ea67c7e6e 100644
--- a/host/lib/usrp_clock/usrp_clock_c.cpp
+++ b/host/lib/usrp_clock/usrp_clock_c.cpp
@@ -7,27 +7,26 @@
/* C-Interface for multi_usrp_clock */
-#include <uhd/utils/static.hpp>
#include <uhd/usrp_clock/multi_usrp_clock.hpp>
-
#include <uhd/usrp_clock/usrp_clock.h>
-
-#include <boost/thread/mutex.hpp>
-
+#include <uhd/utils/static.hpp>
#include <string.h>
+#include <boost/thread/mutex.hpp>
#include <map>
/****************************************************************************
* Registry / Pointer Management
***************************************************************************/
/* Public structs */
-struct uhd_usrp_clock {
+struct uhd_usrp_clock
+{
size_t usrp_clock_index;
std::string last_error;
};
/* Not public: We use this for our internal registry */
-struct usrp_clock_ptr {
+struct usrp_clock_ptr
+{
uhd::usrp_clock::multi_usrp_clock::sptr ptr;
static size_t usrp_clock_counter;
};
@@ -44,122 +43,93 @@ UHD_SINGLETON_FCN(usrp_clock_ptrs, get_usrp_clock_ptrs);
* Generate / Destroy API calls
***************************************************************************/
static boost::mutex _usrp_clock_find_mutex;
-uhd_error uhd_usrp_clock_find(
- const char* args,
- uhd_string_vector_t *devices_out
-){
+uhd_error uhd_usrp_clock_find(const char* args, uhd_string_vector_t* devices_out)
+{
UHD_SAFE_C(
boost::mutex::scoped_lock lock(_usrp_clock_find_mutex);
- uhd::device_addrs_t devs = uhd::device::find(std::string(args), uhd::device::CLOCK);
+ uhd::device_addrs_t devs =
+ uhd::device::find(std::string(args), uhd::device::CLOCK);
devices_out->string_vector_cpp.clear();
- for(const uhd::device_addr_t &dev: devs){
- devices_out->string_vector_cpp.push_back(dev.to_string());
- }
- )
+ for (const uhd::device_addr_t& dev
+ : devs) { devices_out->string_vector_cpp.push_back(dev.to_string()); })
}
static boost::mutex _usrp_clock_make_mutex;
-uhd_error uhd_usrp_clock_make(
- uhd_usrp_clock_handle *h,
- const char *args
-){
- UHD_SAFE_C(
- boost::mutex::scoped_lock lock(_usrp_clock_make_mutex);
+uhd_error uhd_usrp_clock_make(uhd_usrp_clock_handle* h, const char* args)
+{
+ UHD_SAFE_C(boost::mutex::scoped_lock lock(_usrp_clock_make_mutex);
- size_t usrp_clock_count = usrp_clock_ptr::usrp_clock_counter;
- usrp_clock_ptr::usrp_clock_counter++;
+ size_t usrp_clock_count = usrp_clock_ptr::usrp_clock_counter;
+ usrp_clock_ptr::usrp_clock_counter++;
- // Initialize USRP Clock
- uhd::device_addr_t device_addr(args);
- usrp_clock_ptr P;
- P.ptr = uhd::usrp_clock::multi_usrp_clock::make(device_addr);
+ // Initialize USRP Clock
+ uhd::device_addr_t device_addr(args);
+ usrp_clock_ptr P;
+ P.ptr = uhd::usrp_clock::multi_usrp_clock::make(device_addr);
- // Dump into registry
- get_usrp_clock_ptrs()[usrp_clock_count] = P;
+ // Dump into registry
+ get_usrp_clock_ptrs()[usrp_clock_count] = P;
- // Update handle
- (*h) = new uhd_usrp_clock;
- (*h)->usrp_clock_index = usrp_clock_count;
- )
+ // Update handle
+ (*h) = new uhd_usrp_clock;
+ (*h)->usrp_clock_index = usrp_clock_count;)
}
static boost::mutex _usrp_clock_free_mutex;
-uhd_error uhd_usrp_clock_free(
- uhd_usrp_clock_handle *h
-){
- UHD_SAFE_C(
- boost::mutex::scoped_lock lock(_usrp_clock_free_mutex);
-
- if(!get_usrp_clock_ptrs().count((*h)->usrp_clock_index)){
- return UHD_ERROR_INVALID_DEVICE;
- }
-
- get_usrp_clock_ptrs().erase((*h)->usrp_clock_index);
- delete *h;
- *h = NULL;
- )
+uhd_error uhd_usrp_clock_free(uhd_usrp_clock_handle* h)
+{
+ UHD_SAFE_C(boost::mutex::scoped_lock lock(_usrp_clock_free_mutex);
+
+ if (!get_usrp_clock_ptrs().count((*h)->usrp_clock_index)) {
+ return UHD_ERROR_INVALID_DEVICE;
+ }
+
+ get_usrp_clock_ptrs()
+ .erase((*h)->usrp_clock_index);
+ delete *h;
+ *h = NULL;)
}
uhd_error uhd_usrp_clock_last_error(
- uhd_usrp_clock_handle h,
- char* error_out,
- size_t strbuffer_len
-){
- UHD_SAFE_C(
- memset(error_out, '\0', strbuffer_len);
- strncpy(error_out, h->last_error.c_str(), strbuffer_len);
- )
+ uhd_usrp_clock_handle h, char* error_out, size_t strbuffer_len)
+{
+ UHD_SAFE_C(memset(error_out, '\0', strbuffer_len);
+ strncpy(error_out, h->last_error.c_str(), strbuffer_len);)
}
uhd_error uhd_usrp_clock_get_pp_string(
- uhd_usrp_clock_handle h,
- char* pp_string_out,
- size_t strbuffer_len
-){
- UHD_SAFE_C_SAVE_ERROR(h,
- memset(pp_string_out, '\0', strbuffer_len);
- strncpy(pp_string_out, USRP_CLOCK(h)->get_pp_string().c_str(), strbuffer_len);
- )
+ uhd_usrp_clock_handle h, char* pp_string_out, size_t strbuffer_len)
+{
+ UHD_SAFE_C_SAVE_ERROR(h, memset(pp_string_out, '\0', strbuffer_len); strncpy(
+ pp_string_out, USRP_CLOCK(h)->get_pp_string().c_str(), strbuffer_len);)
}
-uhd_error uhd_usrp_clock_get_num_boards(
- uhd_usrp_clock_handle h,
- size_t *num_boards_out
-){
- UHD_SAFE_C_SAVE_ERROR(h,
- *num_boards_out = USRP_CLOCK(h)->get_num_boards();
- )
+uhd_error uhd_usrp_clock_get_num_boards(uhd_usrp_clock_handle h, size_t* num_boards_out)
+{
+ UHD_SAFE_C_SAVE_ERROR(h, *num_boards_out = USRP_CLOCK(h)->get_num_boards();)
}
uhd_error uhd_usrp_clock_get_time(
- uhd_usrp_clock_handle h,
- size_t board,
- uint32_t *clock_time_out
-){
- UHD_SAFE_C_SAVE_ERROR(h,
- *clock_time_out = USRP_CLOCK(h)->get_time(board);
- )
+ uhd_usrp_clock_handle h, size_t board, uint32_t* clock_time_out)
+{
+ UHD_SAFE_C_SAVE_ERROR(h, *clock_time_out = USRP_CLOCK(h)->get_time(board);)
}
-uhd_error uhd_usrp_clock_get_sensor(
- uhd_usrp_clock_handle h,
+uhd_error uhd_usrp_clock_get_sensor(uhd_usrp_clock_handle h,
const char* name,
size_t board,
- uhd_sensor_value_handle *sensor_value_out
-){
- UHD_SAFE_C_SAVE_ERROR(h,
- delete (*sensor_value_out)->sensor_value_cpp;
- (*sensor_value_out)->sensor_value_cpp = new uhd::sensor_value_t(USRP_CLOCK(h)->get_sensor(name, board));
- )
+ uhd_sensor_value_handle* sensor_value_out)
+{
+ UHD_SAFE_C_SAVE_ERROR(h, delete (*sensor_value_out)->sensor_value_cpp;
+ (*sensor_value_out)->sensor_value_cpp = new uhd::sensor_value_t(
+ USRP_CLOCK(h)->get_sensor(name, board));)
}
uhd_error uhd_usrp_clock_get_sensor_names(
- uhd_usrp_clock_handle h,
- size_t board,
- uhd_string_vector_handle *sensor_names_out
-){
- UHD_SAFE_C_SAVE_ERROR(h,
- (*sensor_names_out)->string_vector_cpp = USRP_CLOCK(h)->get_sensor_names(board);
- )
+ uhd_usrp_clock_handle h, size_t board, uhd_string_vector_handle* sensor_names_out)
+{
+ UHD_SAFE_C_SAVE_ERROR(
+ h,
+ (*sensor_names_out)->string_vector_cpp = USRP_CLOCK(h)->get_sensor_names(board);)
}
generated by cgit v1.2.3 (git 2.46.0) at 2025-11-04 06:36:47 +0000