void print_notes_indented( Person *pptr, Str_prt_params *ps_ptr )
{
short old_max_len ;
old_max_len = ps_ptr->max_len ;
ps_ptr->x_pos = ps_ptr->chs_across / 10 ;
ps_ptr->max_len = 4 * ps_ptr->chs_across / 5 ;
print_notes( pptr->notes, ps_ptr ) ;
ps_ptr->max_len = old_max_len ;
}
int main(int argc, char *argv[]) {
int userid, printing = 1, fd; // File descriptor
char searchstring[100];
if (argc > 1) // If there is an arg,
strcpy(searchstring, argv[1]); // that is the search string;
else
searchstring[0] = 0; // search string is empty.
userid = getuid();
fd = open(FILENAME, O_RDONLY); // Open the file for read-only access.
if (fd == -1)
fatal("in main() while opening file for reading");
while(printing)
printing = print_notes(fd, userid, searchstring);
printf("-------[ end of note data ]-------\n");
close(fd);
}
int UHD_SAFE_MAIN(int argc, char *argv[]){
uhd::set_thread_priority_safe();
std::string args;
//Set up program options
po::options_description desc("Allowed options");
desc.add_options()
("help", "help message")
("args", po::value<std::string>(&args)->default_value(""), "Device address arguments specifying a single USRP")
("clock", "query a clock device's sensors")
;
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);
//Print the help message
if (vm.count("help")) {
std::cout << boost::format("Query GPSDO Sensors, try to lock the reference oscillator to the GPS disciplined clock, and set the device time to GPS time")
<< std::endl
<< std::endl
<< desc;
return EXIT_FAILURE;
}
//If specified, query a clock device instead
if(vm.count("clock")) {
return query_clock_sensors(args);
}
//Create a USRP device
std::cout << boost::format("\nCreating the USRP device with: %s...\n") % args;
uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(args);
std::cout << boost::format("Using Device: %s\n") % usrp->get_pp_string();
//Verify GPS sensors are present (i.e. EEPROM has been burnt)
std::vector<std::string> sensor_names = usrp->get_mboard_sensor_names(0);
if(std::find(sensor_names.begin(), sensor_names.end(), "gps_locked") == sensor_names.end()) {
std::cout << boost::format("\ngps_locked sensor not found. This could mean that you have not installed the GPSDO correctly.\n\n");
std::cout << boost::format("Visit one of these pages if the problem persists:\n");
std::cout << boost::format(" * N2X0/E1X0: http://files.ettus.com/manual/page_gpsdo.html");
std::cout << boost::format(" * X3X0: http://files.ettus.com/manual/page_gpsdo_x3x0.html\n\n");
exit(EXIT_FAILURE);
}
// Explicitly set time source to gpsdo
boost::this_thread::sleep(boost::posix_time::seconds(1));
try {
usrp->set_time_source("gpsdo");
} catch (uhd::value_error &e) {
std::cout << "could not set the time source to \"gpsdo\"; error was:" <<std::endl;
std::cout << e.what() << std::endl;
std::cout << "trying \"external\"..." <<std::endl;
try {
usrp->set_time_source("external");
} catch (uhd::value_error&) {
std::cout << "\"external\" failed, too." << std::endl;
}
}
std::cout<< std::endl << "Time source is now " << usrp->get_time_source(0) << std::endl;
//Check for GPS lock
uhd::sensor_value_t gps_locked = usrp->get_mboard_sensor("gps_locked",0);
if(not gps_locked.to_bool()) {
std::cout << boost::format("\nGPS does not have lock. Wait a few minutes and try again.\n");
std::cout << boost::format("NMEA strings and device time may not be accurate until lock is achieved.\n\n");
} else {
std::cout << boost::format("GPS Locked");
}
std::cout << "\nSetting the reference clock source to \"gpsdo\"...\n";
try {
usrp->set_clock_source("gpsdo");
} catch (uhd::value_error &e) {
std::cout << "could not set the clock source to \"gpsdo\"; error was:" <<std::endl;
std::cout << e.what() << std::endl;
std::cout << "trying \"external\"..." <<std::endl;
try{
usrp->set_clock_source("external");
} catch (uhd::value_error&) {
std::cout << "\"external\" failed, too." << std::endl;
}
}
std::cout<< std::endl << "Clock source is now " << usrp->get_clock_source(0) << std::endl;
print_notes();
//Check for 10 MHz lock
if(std::find(sensor_names.begin(), sensor_names.end(), "ref_locked") != sensor_names.end()) {
uhd::sensor_value_t gps_locked = usrp->get_mboard_sensor("ref_locked",0);
if(not gps_locked.to_bool()) {
std::cout << boost::format("USRP NOT Locked to GPSDO 10 MHz Reference.\n");
std::cout << boost::format("Double check installation instructions (N2X0/E1X0 only): https://www.ettus.com/content/files/gpsdo-kit_4.pdf\n\n");
std::cout << boost::format("Locking the internal reference to the GPSDO might take a second to reach stability. Retrying in 10 s...\n\n");
boost::this_thread::sleep(boost::posix_time::seconds(10));
}
if(usrp->get_mboard_sensor("ref_locked",0).to_bool()) {
std::cout << boost::format("USRP Locked to GPSDO 10 MHz Reference.\n");
}
} else {
std::cout << boost::format("ref_locked sensor not present on this board.\n");
}
//Check PPS and compare UHD device time to GPS time
boost::this_thread::sleep(boost::posix_time::seconds(1));
uhd::sensor_value_t gps_time = usrp->get_mboard_sensor("gps_time");
uhd::time_spec_t last_pps_time = usrp->get_time_last_pps();
//we only care about the full seconds
signed gps_seconds = gps_time.to_int();
long long pps_seconds = last_pps_time.to_ticks(1.0);
if(pps_seconds != gps_seconds) {
std::cout << boost::format("\nGPS and UHD Device time are NOT aligned;\nlast_pps: %ld vs gps: %ld. Trying to set the device time to GPS time...")
% pps_seconds % gps_seconds
<< std::endl;
//full next after next second
uhd::time_spec_t next_pps_time(gps_seconds + 2.0);
//instruct the USRP to wait for the next PPS edge, then set the new time on the following PPS
usrp->set_time_unknown_pps(next_pps_time);
//allow some time to make sure the PPS has come…
boost::this_thread::sleep(boost::posix_time::milliseconds(1100));
//…then ask
gps_seconds = usrp->get_mboard_sensor("gps_time").to_int();
pps_seconds = usrp->get_time_last_pps().to_ticks(1.0);
}
std::cout << boost::format("last_pps: %ld vs gps: %ld.")
% pps_seconds % gps_seconds
<< std::endl;
if (pps_seconds == gps_seconds) {
std::cout << boost::format("GPS and UHD Device time are aligned.\n");
} else {
std::cout << boost::format("Could not align UHD Device time to GPS time. Giving up.\n");
}
//print NMEA strings
try {
uhd::sensor_value_t gga_string = usrp->get_mboard_sensor("gps_gpgga");
uhd::sensor_value_t rmc_string = usrp->get_mboard_sensor("gps_gprmc");
std::cout << boost::format("Printing available NMEA strings:\n");
std::cout << boost::format("%s\n%s\n") % gga_string.to_pp_string() % rmc_string.to_pp_string();
} catch (uhd::lookup_error&) {
std::cout << "NMEA strings not implemented for this device." << std::endl;
}
std::cout << boost::format("GPS Epoch time at last PPS: %.5f seconds\n") % usrp->get_mboard_sensor("gps_time").to_real();
std::cout << boost::format("UHD Device time last PPS: %.5f seconds\n") % (usrp->get_time_last_pps().get_real_secs());
std::cout << boost::format("UHD Device time right now: %.5f seconds\n") % (usrp->get_time_now().get_real_secs());
std::cout << boost::format("PC Clock time: %.5f seconds\n") % time(NULL);
//finished
std::cout << boost::format("\nDone!\n\n");
return EXIT_SUCCESS;
}
int UHD_SAFE_MAIN(int argc, char* argv[])
{
uhd::set_thread_priority_safe();
std::string args;
// Set up program options
po::options_description desc("Allowed options");
// clang-format off
desc.add_options()
("help", "help message")
("args", po::value<std::string>(&args)->default_value(""), "Device address arguments specifying a single USRP")
("clock", "query a clock device's sensors")
;
// clang-format on
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);
// Print the help message
if (vm.count("help")) {
std::cout << boost::format(
"Query GPSDO Sensors, try to lock the reference oscillator to "
"the GPS disciplined clock, and set the device time to GPS time")
<< std::endl
<< std::endl
<< desc;
return EXIT_FAILURE;
}
// If specified, query a clock device instead
if (vm.count("clock")) {
return query_clock_sensors(args);
}
// Create a USRP device
std::cout << boost::format("\nCreating the USRP device with: %s...\n") % args;
uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(args);
std::cout << boost::format("Using Device: %s\n") % usrp->get_pp_string();
// Verify GPS sensors are present (i.e. EEPROM has been burnt)
std::vector<std::string> sensor_names = usrp->get_mboard_sensor_names(0);
if (std::find(sensor_names.begin(), sensor_names.end(), "gps_locked")
== sensor_names.end()) {
std::cout << boost::format("\ngps_locked sensor not found. This could mean that "
"you have not installed the GPSDO correctly.\n\n");
std::cout << boost::format("Visit one of these pages if the problem persists:\n");
std::cout << boost::format(
" * N2X0/E1X0: http://files.ettus.com/manual/page_gpsdo.html\n");
std::cout << boost::format(
" * X3X0: http://files.ettus.com/manual/page_gpsdo_x3x0.html\n\n");
return EXIT_FAILURE;
}
bool ref_set_to_gpsdo = false;
// Set clock source to gpsdo if supported
if (uhd::has(usrp->get_clock_sources(0), "gpsdo")) {
std::cout << "Setting the reference clock source to \"gpsdo\"..." << std::endl;
usrp->set_clock_source("gpsdo");
ref_set_to_gpsdo = true;
}
std::cout << "Clock source is now " << usrp->get_clock_source(0) << std::endl;
// Set time source to gpsdo if supported
if (uhd::has(usrp->get_time_sources(0), "gpsdo")) {
std::cout << "Setting the reference clock source to \"gpsdo\"..." << std::endl;
usrp->set_time_source("gpsdo");
ref_set_to_gpsdo = true;
}
std::cout << "Time source is now " << usrp->get_time_source(0) << std::endl;
if (not ref_set_to_gpsdo) {
std::cerr << "ERROR: Unable to set clock or time reference to \"gpsdo\""
<< std::endl;
return EXIT_FAILURE;
}
// Check for ref lock
if (std::find(sensor_names.begin(), sensor_names.end(), "ref_locked")
!= sensor_names.end()) {
uhd::sensor_value_t ref_locked = usrp->get_mboard_sensor("ref_locked", 0);
for (size_t i = 0; not ref_locked.to_bool() and i < 300; i++) {
std::this_thread::sleep_for(std::chrono::milliseconds(100));
ref_locked = usrp->get_mboard_sensor("ref_locked", 0);
}
if (not ref_locked.to_bool()) {
std::cout << boost::format("USRP NOT Locked to Reference.\n");
std::cout << boost::format(
"Double check installation instructions (N2X0/E1X0 only): "
"https://www.ettus.com/content/files/gpsdo-kit_4.pdf\n\n");
return EXIT_FAILURE;
} else {
std::cout << boost::format("USRP Locked to Reference.\n");
}
} else {
std::cout << boost::format("ref_locked sensor not present on this board.\n");
}
print_notes();
// The TCXO has a long warm up time, so wait up to 30 seconds for sensor data
// to show up
std::cout << "Waiting for the GPSDO to warm up..." << std::flush;
auto end = std::chrono::steady_clock::now() + std::chrono::seconds(30);
while (std::chrono::steady_clock::now() < end) {
try {
usrp->get_mboard_sensor("gps_locked", 0);
break;
} catch (std::exception&) {
}
std::this_thread::sleep_for(std::chrono::milliseconds(250));
std::cout << "." << std::flush;
}
std::cout << std::endl;
try {
usrp->get_mboard_sensor("gps_locked", 0);
} catch (std::exception&) {
std::cout << "No response from GPSDO in 30 seconds" << std::endl;
return EXIT_FAILURE;
}
std::cout << "The GPSDO is warmed up and talking." << std::endl;
// Check for GPS lock
uhd::sensor_value_t gps_locked = usrp->get_mboard_sensor("gps_locked", 0);
;
if (not gps_locked.to_bool()) {
std::cout << boost::format(
"\nGPS does not have lock. Wait a few minutes and try again.\n");
std::cout << boost::format("NMEA strings and device time may not be accurate "
"until lock is achieved.\n\n");
} else {
std::cout << boost::format("GPS Locked");
}
// Check PPS and compare UHD device time to GPS time
uhd::sensor_value_t gps_time = usrp->get_mboard_sensor("gps_time");
uhd::time_spec_t last_pps_time = usrp->get_time_last_pps();
// we only care about the full seconds
signed gps_seconds = gps_time.to_int();
long long pps_seconds = last_pps_time.to_ticks(1.0);
if (pps_seconds != gps_seconds) {
std::cout << "\nTrying to align the device time to GPS time..." << std::endl;
gps_time = usrp->get_mboard_sensor("gps_time");
// set the device time to the GPS time
// getting the GPS time returns just after the PPS edge, so just add a
// second and set the device time at the next PPS edge
usrp->set_time_next_pps(uhd::time_spec_t(gps_time.to_int() + 1.0));
// allow some time to make sure the PPS has come…
std::this_thread::sleep_for(std::chrono::milliseconds(1100));
//…then ask
gps_seconds = usrp->get_mboard_sensor("gps_time").to_int();
pps_seconds = usrp->get_time_last_pps().to_ticks(1.0);
}
if (pps_seconds == gps_seconds) {
std::cout << boost::format("GPS and UHD Device time are aligned.\n");
} else {
std::cout << boost::format(
"Could not align UHD Device time to GPS time. Giving up.\n");
}
std::cout << boost::format("last_pps: %ld vs gps: %ld.") % pps_seconds % gps_seconds
<< std::endl;
// print NMEA strings
try {
uhd::sensor_value_t gga_string = usrp->get_mboard_sensor("gps_gpgga");
uhd::sensor_value_t rmc_string = usrp->get_mboard_sensor("gps_gprmc");
std::cout << boost::format("Printing available NMEA strings:\n");
std::cout << boost::format("%s\n%s\n") % gga_string.to_pp_string()
% rmc_string.to_pp_string();
} catch (uhd::lookup_error&) {
std::cout << "NMEA strings not implemented for this device." << std::endl;
}
std::cout << boost::format("GPS Epoch time at last PPS: %.5f seconds\n")
% usrp->get_mboard_sensor("gps_time").to_real();
std::cout << boost::format("UHD Device time last PPS: %.5f seconds\n")
% (usrp->get_time_last_pps().get_real_secs());
std::cout << boost::format("UHD Device time right now: %.5f seconds\n")
% (usrp->get_time_now().get_real_secs());
std::cout << boost::format("PC Clock time: %.5f seconds\n") % time(NULL);
// finished
std::cout << boost::format("\nDone!\n\n");
return EXIT_SUCCESS;
}
int UHD_SAFE_MAIN(int argc, char *argv[])
{
uhd::set_thread_priority_safe();
std::string args;
//Set up program options
po::options_description desc("Allowed options");
desc.add_options()
("help", "help message")
("args", po::value<std::string>(&args)->default_value(""), "USRP device arguments")
;
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);
//Print the help message
if (vm.count("help"))
{
std::cout << boost::format("Synchronize USRP to GPS %s") % desc << std::endl;
return EXIT_FAILURE;
}
//Create a USRP device
std::cout << boost::format("\nCreating the USRP device with: %s...\n") % args;
uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(args);
std::cout << boost::format("Using Device: %s\n") % usrp->get_pp_string();
try
{
size_t num_mboards = usrp->get_num_mboards();
size_t num_gps_locked = 0;
for (size_t mboard = 0; mboard < num_mboards; mboard++)
{
std::cout << "Synchronizing mboard " << mboard << ": " << usrp->get_mboard_name(mboard) << std::endl;
//Set references to GPSDO
usrp->set_clock_source("gpsdo", mboard);
usrp->set_time_source("gpsdo", mboard);
std::cout << std::endl;
print_notes();
std::cout << std::endl;
//Check for 10 MHz lock
std::vector<std::string> sensor_names = usrp->get_mboard_sensor_names(mboard);
if(std::find(sensor_names.begin(), sensor_names.end(), "ref_locked") != sensor_names.end())
{
std::cout << "Waiting for reference lock..." << std::flush;
bool ref_locked = false;
for (int i = 0; i < 30 and not ref_locked; i++)
{
ref_locked = usrp->get_mboard_sensor("ref_locked", mboard).to_bool();
if (not ref_locked)
{
std::cout << "." << std::flush;
boost::this_thread::sleep(boost::posix_time::seconds(1));
}
}
if(ref_locked)
{
std::cout << "LOCKED" << std::endl;
} else {
std::cout << "FAILED" << std::endl;
std::cout << "Failed to lock to GPSDO 10 MHz Reference. Exiting." << std::endl;
exit(EXIT_FAILURE);
}
}
else
{
std::cout << boost::format("ref_locked sensor not present on this board.\n");
}
//Wait for GPS lock
bool gps_locked = usrp->get_mboard_sensor("gps_locked", mboard).to_bool();
if(gps_locked)
{
num_gps_locked++;
std::cout << boost::format("GPS Locked\n");
}
else
{
std::cerr << "WARNING: GPS not locked - time will not be accurate until locked" << std::endl;
}
//Set to GPS time
uhd::time_spec_t gps_time = uhd::time_spec_t(time_t(usrp->get_mboard_sensor("gps_time", mboard).to_int()));
usrp->set_time_next_pps(gps_time+1.0, mboard);
//Wait for it to apply
//The wait is 2 seconds because N-Series has a known issue where
//the time at the last PPS does not properly update at the PPS edge
//when the time is actually set.
boost::this_thread::sleep(boost::posix_time::seconds(2));
//Check times
gps_time = uhd::time_spec_t(time_t(usrp->get_mboard_sensor("gps_time", mboard).to_int()));
uhd::time_spec_t time_last_pps = usrp->get_time_last_pps(mboard);
std::cout << "USRP time: " << (boost::format("%0.9f") % time_last_pps.get_real_secs()) << std::endl;
std::cout << "GPSDO time: " << (boost::format("%0.9f") % gps_time.get_real_secs()) << std::endl;
if (gps_time.get_real_secs() == time_last_pps.get_real_secs())
std::cout << std::endl << "SUCCESS: USRP time synchronized to GPS time" << std::endl << std::endl;
else
std::cerr << std::endl << "ERROR: Failed to synchronize USRP time to GPS time" << std::endl << std::endl;
}
if (num_gps_locked == num_mboards and num_mboards > 1)
{
//Check to see if all USRP times are aligned
//First, wait for PPS.
uhd::time_spec_t time_last_pps = usrp->get_time_last_pps();
while (time_last_pps == usrp->get_time_last_pps())
{
boost::this_thread::sleep(boost::posix_time::milliseconds(1));
}
//Sleep a little to make sure all devices have seen a PPS edge
boost::this_thread::sleep(boost::posix_time::milliseconds(200));
//Compare times across all mboards
bool all_matched = true;
uhd::time_spec_t mboard0_time = usrp->get_time_last_pps(0);
for (size_t mboard = 1; mboard < num_mboards; mboard++)
{
uhd::time_spec_t mboard_time = usrp->get_time_last_pps(mboard);
if (mboard_time != mboard0_time)
{
all_matched = false;
std::cerr << (boost::format("ERROR: Times are not aligned: USRP 0=%0.9f, USRP %d=%0.9f")
% mboard0_time.get_real_secs()
% mboard
% mboard_time.get_real_secs()) << std::endl;
}
}
if (all_matched)
{
std::cout << "SUCCESS: USRP times aligned" << std::endl << std::endl;
} else {
std::cout << "ERROR: USRP times are not aligned" << std::endl << std::endl;
}
}
}
catch (std::exception& e)
{
std::cout << boost::format("\nError: %s") % e.what();
std::cout << boost::format("This could mean that you have not installed the GPSDO correctly.\n\n");
std::cout << boost::format("Visit one of these pages if the problem persists:\n");
std::cout << boost::format(" * N2X0/E1X0: http://files.ettus.com/manual/page_gpsdo.html");
std::cout << boost::format(" * X3X0: http://files.ettus.com/manual/page_gpsdo_x3x0.html\n\n");
std::cout << boost::format(" * E3X0: http://files.ettus.com/manual/page_usrp_e3x0.html#e3x0_hw_gps\n\n");
exit(EXIT_FAILURE);
}
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
const char *f;
int fd,h,size,usize,count;
void *image,*tmp;
struct stat st;
struct elf_binary elf;
const elf_shdr *shdr;
int notes_found = 0;
if (argc != 2)
{
fprintf(stderr, "Usage: readnotes <elfimage>\n");
return 1;
}
f = argv[1];
fd = open(f, O_RDONLY);
if (fd == -1)
{
fprintf(stderr, "Unable to open %s: %s\n", f, strerror(errno));
return 1;
}
if (fstat(fd, &st) == -1)
{
fprintf(stderr, "Unable to determine size of %s: %s\n",
f, strerror(errno));
return 1;
}
image = mmap(0, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
if (image == MAP_FAILED)
{
fprintf(stderr, "Unable to map %s: %s\n", f, strerror(errno));
return 1;
}
size = st.st_size;
usize = xc_dom_check_gzip(image, st.st_size);
if (usize)
{
tmp = malloc(usize);
xc_dom_do_gunzip(image, st.st_size, tmp, usize);
image = tmp;
size = usize;
}
if (0 != elf_init(&elf, image, size))
{
fprintf(stderr, "File %s is not an ELF image\n", f);
return 1;
}
elf_set_logfile(&elf, stderr, 0);
count = elf_phdr_count(&elf);
for ( h=0; h < count; h++)
{
const elf_phdr *phdr;
phdr = elf_phdr_by_index(&elf, h);
if (elf_uval(&elf, phdr, p_type) != PT_NOTE)
continue;
/* Some versions of binutils do not correctly set
* p_offset for note segments.
*/
if (elf_uval(&elf, phdr, p_offset) == 0)
continue;
notes_found = print_notes(&elf,
elf_segment_start(&elf, phdr),
elf_segment_end(&elf, phdr));
}
if ( notes_found == 0 )
{
count = elf_shdr_count(&elf);
for ( h=0; h < count; h++)
{
const elf_shdr *shdr;
shdr = elf_shdr_by_index(&elf, h);
if (elf_uval(&elf, shdr, sh_type) != SHT_NOTE)
continue;
notes_found = print_notes(&elf,
elf_section_start(&elf, shdr),
elf_section_end(&elf, shdr));
if ( notes_found )
fprintf(stderr, "using notes from SHT_NOTE section\n");
}
}
shdr = elf_shdr_by_name(&elf, "__xen_guest");
if (shdr)
printf("__xen_guest: %s\n", (char*)elf_section_start(&elf, shdr));
return 0;
}
