Added timestamping of bursts in the gsm receiver
This commit is contained in:
Piotr Krysik
parent
c6fad1f954
commit
df978693eb
|
|
@ -23,4 +23,6 @@ add_sources(
|
|||
receiver_config.cc
|
||||
receiver_impl.cc
|
||||
viterbi_detector.cc
|
||||
time_spec.cc
|
||||
time_sample_ref.cc
|
||||
)
|
||||
|
|
|
|||
|
|
@ -74,10 +74,12 @@ namespace gr
|
|||
) : gr::sync_block("receiver",
|
||||
gr::io_signature::make(1, -1, sizeof(gr_complex)),
|
||||
gr::io_signature::make(0, 0, 0)),
|
||||
d_rx_time_received(false),
|
||||
d_time_samp_ref(GSM_SYMBOL_RATE * osr),
|
||||
d_OSR(osr),
|
||||
d_process_uplink(process_uplink),
|
||||
d_chan_imp_length(CHAN_IMP_RESP_LENGTH),
|
||||
d_counter(0),
|
||||
d_counter(0), //TODO: use nitems_read instead of d_counter
|
||||
d_fcch_start_pos(0),
|
||||
d_freq_offset_setting(0),
|
||||
d_state(fcch_search),
|
||||
|
|
@ -147,6 +149,7 @@ namespace gr
|
|||
std::vector<const gr_complex *> iii =
|
||||
(std::vector<const gr_complex *>) input_items;
|
||||
#endif
|
||||
|
||||
|
||||
/* Time synchronization loop */
|
||||
float current_time =
|
||||
|
|
@ -175,7 +178,25 @@ namespace gr
|
|||
d_freq_offset_tag_in_fcch = tag_offset < last_sample_nr;
|
||||
}
|
||||
}
|
||||
|
||||
/* Obtaining current time with use of rx_time tag provided i.e. by UHD devices */
|
||||
/* And storing it in time_sample_ref for sample number to time conversion */
|
||||
std::vector<tag_t> rx_time_tags;
|
||||
|
||||
get_tags_in_window(rx_time_tags, 0, 0, noutput_items, pmt::string_to_symbol("rx_time"));
|
||||
if(!rx_time_tags.empty()){
|
||||
d_rx_time_received = true;
|
||||
tag_t rx_time_tag = *(rx_time_tags.begin());
|
||||
|
||||
uint64_t rx_time_full_part = to_uint64(tuple_ref(rx_time_tag.value,0));
|
||||
double rx_time_frac_part = to_double(tuple_ref(rx_time_tag.value,1));
|
||||
|
||||
time_spec_t current_rx_time = time_spec_t(rx_time_full_part, rx_time_frac_part);
|
||||
uint64_t current_start_offset = rx_time_tag.offset;
|
||||
d_time_samp_ref.update(current_rx_time, current_start_offset);
|
||||
// std::cout << "Mam rx_time: " << current_rx_time.get_real_secs() << std::endl;
|
||||
}
|
||||
|
||||
/* Main state machine */
|
||||
switch (d_state) {
|
||||
case fcch_search:
|
||||
|
|
@ -335,7 +356,7 @@ namespace gr
|
|||
|
||||
/* Compose a message with GSMTAP header and bits */
|
||||
send_burst(d_burst_nr, output_binary,
|
||||
GSMTAP_BURST_SCH, input_nr);
|
||||
GSMTAP_BURST_SCH, input_nr, d_c0_burst_start);
|
||||
|
||||
/* Attempt to decode SCH burst */
|
||||
rc = decode_sch(&output_binary[3], &t1, &t2, &t3, &d_ncc, &d_bcc);
|
||||
|
|
@ -381,7 +402,7 @@ namespace gr
|
|||
|
||||
/* Compose a message with GSMTAP header and bits */
|
||||
send_burst(d_burst_nr, output_binary,
|
||||
GSMTAP_BURST_NORMAL, input_nr);
|
||||
GSMTAP_BURST_NORMAL, input_nr, d_c0_burst_start);
|
||||
|
||||
break;
|
||||
}
|
||||
|
|
@ -405,13 +426,13 @@ namespace gr
|
|||
|
||||
/* Compose a message with GSMTAP header and bits */
|
||||
send_burst(d_burst_nr, output_binary,
|
||||
GSMTAP_BURST_NORMAL, input_nr);
|
||||
GSMTAP_BURST_NORMAL, input_nr, normal_burst_start);
|
||||
} else {
|
||||
d_c0_burst_start = dummy_burst_start;
|
||||
|
||||
/* Compose a message with GSMTAP header and bits */
|
||||
send_burst(d_burst_nr, dummy_burst,
|
||||
GSMTAP_BURST_DUMMY, input_nr);
|
||||
GSMTAP_BURST_DUMMY, input_nr, dummy_burst_start);
|
||||
}
|
||||
|
||||
break;
|
||||
|
|
@ -463,7 +484,7 @@ namespace gr
|
|||
burst_start, output_binary);
|
||||
|
||||
/* Compose a message with GSMTAP header and bits */
|
||||
send_burst(d_burst_nr, output_binary, GSMTAP_BURST_NORMAL, input_nr);
|
||||
send_burst(d_burst_nr, output_binary, GSMTAP_BURST_NORMAL, input_nr, burst_start);
|
||||
|
||||
break;
|
||||
}
|
||||
|
|
@ -980,7 +1001,7 @@ namespace gr
|
|||
void
|
||||
receiver_impl::send_burst(burst_counter burst_nr,
|
||||
const unsigned char * burst_binary, uint8_t burst_type,
|
||||
unsigned int input_nr)
|
||||
unsigned int input_nr, unsigned int burst_start)
|
||||
{
|
||||
/* Buffer for GSMTAP header and burst */
|
||||
uint8_t buf[sizeof(gsmtap_hdr) + BURST_SIZE];
|
||||
|
|
@ -1019,6 +1040,17 @@ namespace gr
|
|||
tap_header->signal_dbm = static_cast<int8_t>(d_signal_dbm);
|
||||
tap_header->snr_db = 0; /* FIXME: Can we calculate this? */
|
||||
|
||||
pmt::pmt_t pdu_header = pmt::make_dict();
|
||||
|
||||
/* Add timestamp of the first sample - if available */
|
||||
if(d_rx_time_received) {
|
||||
time_spec_t time_spec_of_first_sample = d_time_samp_ref.offset_to_time(nitems_read(0)+burst_start);
|
||||
uint64_t full = time_spec_of_first_sample.get_full_secs();
|
||||
double frac = time_spec_of_first_sample.get_frac_secs();
|
||||
pdu_header =
|
||||
pmt::dict_add(pdu_header, pmt::mp("fn_time"), pmt::cons(pmt::from_uint64(frame_number), pmt::cons(pmt::from_uint64(full), pmt::from_double(frac))));
|
||||
}
|
||||
|
||||
/* Copy burst to the buffer */
|
||||
memcpy(burst, burst_binary, BURST_SIZE);
|
||||
|
||||
|
|
@ -1093,6 +1125,5 @@ namespace gr
|
|||
{
|
||||
d_state = fcch_search;
|
||||
}
|
||||
|
||||
} /* namespace gsm */
|
||||
} /* namespace gr */
|
||||
|
|
|
|||
|
|
@ -28,12 +28,15 @@
|
|||
#include <gsm_constants.h>
|
||||
#include <receiver_config.h>
|
||||
#include <vector>
|
||||
#include "time_sample_ref.h"
|
||||
|
||||
namespace gr {
|
||||
namespace gsm {
|
||||
class receiver_impl : public receiver
|
||||
{
|
||||
private:
|
||||
bool d_rx_time_received;
|
||||
time_sample_ref d_time_samp_ref;
|
||||
unsigned int d_c0_burst_start;
|
||||
float d_c0_signal_dbm;
|
||||
|
||||
|
|
@ -195,7 +198,7 @@ namespace gr {
|
|||
* @param burst_binary - content of the burst
|
||||
* @b_type - type of the burst
|
||||
*/
|
||||
void send_burst(burst_counter burst_nr, const unsigned char * burst_binary, uint8_t burst_type, unsigned int input_nr);
|
||||
void send_burst(burst_counter burst_nr, const unsigned char * burst_binary, uint8_t burst_type, unsigned int input_nr, unsigned int burst_start=-1);
|
||||
|
||||
/**
|
||||
* Configures burst types in different channels
|
||||
|
|
@ -209,13 +212,13 @@ namespace gr {
|
|||
gr_vector_const_void_star &input_items, int noutput_items);
|
||||
|
||||
public:
|
||||
receiver_impl(int osr, const std::vector<int> &cell_allocation, const std::vector<int> &tseq_nums, bool process_uplink);
|
||||
~receiver_impl();
|
||||
receiver_impl(int osr, const std::vector<int> &cell_allocation, const std::vector<int> &tseq_nums, bool process_uplink);
|
||||
~receiver_impl();
|
||||
|
||||
int work(int noutput_items, gr_vector_const_void_star &input_items, gr_vector_void_star &output_items);
|
||||
virtual void set_cell_allocation(const std::vector<int> &cell_allocation);
|
||||
virtual void set_tseq_nums(const std::vector<int> & tseq_nums);
|
||||
virtual void reset();
|
||||
int work(int noutput_items, gr_vector_const_void_star &input_items, gr_vector_void_star &output_items);
|
||||
virtual void set_cell_allocation(const std::vector<int> &cell_allocation);
|
||||
virtual void set_tseq_nums(const std::vector<int> & tseq_nums);
|
||||
virtual void reset();
|
||||
};
|
||||
} // namespace gsm
|
||||
} // namespace gr
|
||||
|
|
|
|||
|
|
@ -0,0 +1,60 @@
|
|||
/* -*- c++ -*- */
|
||||
/*
|
||||
* @file
|
||||
* @author (C) 2017 by Piotr Krysik <ptrkrysik@gmail.com>
|
||||
* @section LICENSE
|
||||
*
|
||||
* Gr-gsm is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 3, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* Gr-gsm is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with gr-gsm; see the file COPYING. If not, write to
|
||||
* the Free Software Foundation, Inc., 51 Franklin Street,
|
||||
* Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include <math.h>
|
||||
#include "time_sample_ref.h"
|
||||
|
||||
namespace gr {
|
||||
namespace gsm {
|
||||
time_sample_ref::time_sample_ref(double samp_rate): d_samp_rate(samp_rate)
|
||||
{
|
||||
}
|
||||
|
||||
time_sample_ref::~time_sample_ref()
|
||||
{
|
||||
}
|
||||
|
||||
void time_sample_ref::update(time_spec_t last_rx_time, uint64_t current_start_offset)
|
||||
{
|
||||
d_last_rx_time = last_rx_time;
|
||||
d_current_start_offset = current_start_offset;
|
||||
}
|
||||
|
||||
time_spec_t time_sample_ref::offset_to_time(uint64_t offset)
|
||||
{
|
||||
uint64_t samples_from_last_rx_time = offset - d_current_start_offset;
|
||||
time_spec_t time = time_spec_t(static_cast<double>(samples_from_last_rx_time)/d_samp_rate) + d_last_rx_time;
|
||||
|
||||
return time;
|
||||
}
|
||||
|
||||
uint64_t time_sample_ref::time_to_offset(time_spec_t time)
|
||||
{
|
||||
double samples_since_last_rx_time_tag = (time-d_last_rx_time).get_real_secs()*d_samp_rate;
|
||||
// double fractional_part = round(samples_since_last_rx_time_tag) - samples_since_last_rx_time_tag;
|
||||
uint64_t offset = static_cast<uint64_t>(round(samples_since_last_rx_time_tag)) + d_current_start_offset;
|
||||
|
||||
return offset;
|
||||
}
|
||||
} // namespace gsm
|
||||
} // namespace gr
|
||||
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
/* -*- c++ -*- */
|
||||
/*
|
||||
* @file
|
||||
* @author (C) 2017 by Piotr Krysik <ptrkrysik@gmail.com>
|
||||
* @section LICENSE
|
||||
*
|
||||
* Gr-gsm is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 3, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* Gr-gsm is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with gr-gsm; see the file COPYING. If not, write to
|
||||
* the Free Software Foundation, Inc., 51 Franklin Street,
|
||||
* Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#ifndef INCLUDED_TIME_SAMPLE_REF_IMPL_H
|
||||
#define INCLUDED_TIME_SAMPLE_REF_IMPL_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include "time_spec.h"
|
||||
|
||||
namespace gr {
|
||||
namespace gsm {
|
||||
/*
|
||||
Class for storing time reference and for conversions time<->sample number
|
||||
*/
|
||||
class time_sample_ref
|
||||
{
|
||||
private:
|
||||
double d_samp_rate;
|
||||
time_spec_t d_last_rx_time;
|
||||
uint64_t d_current_start_offset;
|
||||
public:
|
||||
time_sample_ref(double samp_rate);
|
||||
~time_sample_ref();
|
||||
void update(time_spec_t last_rx_time, uint64_t current_start_offset);
|
||||
time_spec_t offset_to_time(uint64_t offset);
|
||||
uint64_t time_to_offset(time_spec_t time);
|
||||
};
|
||||
} // namespace gsm
|
||||
} // namespace gr
|
||||
#endif// INCLUDED_TIME_SAMPLE_REF_IMPL_H
|
||||
|
|
@ -0,0 +1,170 @@
|
|||
//
|
||||
// Copyright 2011-2013 Ettus Research LLC
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
|
||||
#include "time_spec.h"
|
||||
|
||||
namespace gr {
|
||||
namespace gsm {
|
||||
|
||||
/***********************************************************************
|
||||
* Time spec system time
|
||||
**********************************************************************/
|
||||
|
||||
#ifdef HAVE_CLOCK_GETTIME
|
||||
#include <time.h>
|
||||
time_spec_t time_spec_t::get_system_time(void){
|
||||
timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts);
|
||||
return time_spec_t(ts.tv_sec, ts.tv_nsec, 1e9);
|
||||
}
|
||||
#endif /* HAVE_CLOCK_GETTIME */
|
||||
|
||||
|
||||
#ifdef HAVE_MACH_ABSOLUTE_TIME
|
||||
#include <mach/mach_time.h>
|
||||
time_spec_t time_spec_t::get_system_time(void){
|
||||
mach_timebase_info_data_t info; mach_timebase_info(&info);
|
||||
intmax_t nanosecs = mach_absolute_time()*info.numer/info.denom;
|
||||
return time_spec_t::from_ticks(nanosecs, 1e9);
|
||||
}
|
||||
#endif /* HAVE_MACH_ABSOLUTE_TIME */
|
||||
|
||||
|
||||
#ifdef HAVE_QUERY_PERFORMANCE_COUNTER
|
||||
#include <Windows.h>
|
||||
time_spec_t time_spec_t::get_system_time(void){
|
||||
LARGE_INTEGER counts, freq;
|
||||
QueryPerformanceCounter(&counts);
|
||||
QueryPerformanceFrequency(&freq);
|
||||
return time_spec_t::from_ticks(counts.QuadPart, double(freq.QuadPart));
|
||||
}
|
||||
#endif /* HAVE_QUERY_PERFORMANCE_COUNTER */
|
||||
|
||||
|
||||
#ifdef HAVE_MICROSEC_CLOCK
|
||||
#include <boost/date_time/posix_time/posix_time.hpp>
|
||||
namespace pt = boost::posix_time;
|
||||
time_spec_t time_spec_t::get_system_time(void){
|
||||
pt::ptime time_now = pt::microsec_clock::universal_time();
|
||||
pt::time_duration time_dur = time_now - pt::from_time_t(0);
|
||||
return time_spec_t(
|
||||
time_t(time_dur.total_seconds()),
|
||||
long(time_dur.fractional_seconds()),
|
||||
double(pt::time_duration::ticks_per_second())
|
||||
);
|
||||
}
|
||||
#endif /* HAVE_MICROSEC_CLOCK */
|
||||
|
||||
/***********************************************************************
|
||||
* Time spec constructors
|
||||
**********************************************************************/
|
||||
#define time_spec_init(full, frac) { \
|
||||
const time_t _full = time_t(full); \
|
||||
const double _frac = double(frac); \
|
||||
const int _frac_int = int(_frac); \
|
||||
_full_secs = _full + _frac_int; \
|
||||
_frac_secs = _frac - _frac_int; \
|
||||
if (_frac_secs < 0) {\
|
||||
_full_secs -= 1; \
|
||||
_frac_secs += 1; \
|
||||
} \
|
||||
}
|
||||
|
||||
inline long long fast_llround(const double x){
|
||||
return (long long)(x + 0.5); // assumption of non-negativity
|
||||
}
|
||||
|
||||
time_spec_t::time_spec_t(const time_spec_t & spec){
|
||||
time_spec_init(spec.get_full_secs(), spec.get_frac_secs());
|
||||
}
|
||||
|
||||
time_spec_t::time_spec_t(double secs){
|
||||
time_spec_init(0, secs);
|
||||
}
|
||||
|
||||
time_spec_t::time_spec_t(time_t full_secs, double frac_secs){
|
||||
time_spec_init(full_secs, frac_secs);
|
||||
}
|
||||
|
||||
time_spec_t::time_spec_t(time_t full_secs, long tick_count, double tick_rate){
|
||||
const double frac_secs = tick_count/tick_rate;
|
||||
time_spec_init(full_secs, frac_secs);
|
||||
}
|
||||
|
||||
time_spec_t time_spec_t::from_ticks(long long ticks, double tick_rate){
|
||||
const long long rate_i = (long long)(tick_rate);
|
||||
const double rate_f = tick_rate - rate_i;
|
||||
const time_t secs_full = time_t(ticks/rate_i);
|
||||
const long long ticks_error = ticks - (secs_full*rate_i);
|
||||
const double ticks_frac = ticks_error - secs_full*rate_f;
|
||||
return time_spec_t(secs_full, ticks_frac/tick_rate);
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
* Time spec accessors
|
||||
**********************************************************************/
|
||||
long time_spec_t::get_tick_count(double tick_rate) const{
|
||||
return long(fast_llround(this->get_frac_secs()*tick_rate));
|
||||
}
|
||||
|
||||
long long time_spec_t::to_ticks(double tick_rate) const{
|
||||
const long long rate_i = (long long)(tick_rate);
|
||||
const double rate_f = tick_rate - rate_i;
|
||||
const long long ticks_full = this->get_full_secs()*rate_i;
|
||||
const double ticks_error = this->get_full_secs()*rate_f;
|
||||
const double ticks_frac = this->get_frac_secs()*tick_rate;
|
||||
return ticks_full + fast_llround(ticks_error + ticks_frac);
|
||||
}
|
||||
|
||||
double time_spec_t::get_real_secs(void) const{
|
||||
return this->get_full_secs() + this->get_frac_secs();
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
* Time spec math overloads
|
||||
**********************************************************************/
|
||||
time_spec_t &time_spec_t::operator+=(const time_spec_t &rhs){
|
||||
time_spec_init(
|
||||
this->get_full_secs() + rhs.get_full_secs(),
|
||||
this->get_frac_secs() + rhs.get_frac_secs()
|
||||
);
|
||||
return *this;
|
||||
}
|
||||
|
||||
time_spec_t &time_spec_t::operator-=(const time_spec_t &rhs){
|
||||
time_spec_init(
|
||||
this->get_full_secs() - rhs.get_full_secs(),
|
||||
this->get_frac_secs() - rhs.get_frac_secs()
|
||||
);
|
||||
return *this;
|
||||
}
|
||||
|
||||
bool operator==(const time_spec_t &lhs, const time_spec_t &rhs){
|
||||
return
|
||||
lhs.get_full_secs() == rhs.get_full_secs() and
|
||||
lhs.get_frac_secs() == rhs.get_frac_secs()
|
||||
;
|
||||
}
|
||||
|
||||
bool operator<(const time_spec_t &lhs, const time_spec_t &rhs){
|
||||
return (
|
||||
(lhs.get_full_secs() < rhs.get_full_secs()) or (
|
||||
(lhs.get_full_secs() == rhs.get_full_secs()) and
|
||||
(lhs.get_frac_secs() < rhs.get_frac_secs())
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,147 @@
|
|||
//
|
||||
// Copyright 2010-2012 Ettus Research LLC
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
|
||||
#ifndef INCLUDED_TYPES_TIME_SPEC_HPP
|
||||
#define INCLUDED_TYPES_TIME_SPEC_HPP
|
||||
|
||||
#include <boost/operators.hpp>
|
||||
#include <ctime>
|
||||
|
||||
namespace gr {
|
||||
namespace gsm {
|
||||
|
||||
/*!
|
||||
* A time_spec_t holds a seconds and a fractional seconds time value.
|
||||
* Depending upon usage, the time_spec_t can represent absolute times,
|
||||
* relative times, or time differences (between absolute times).
|
||||
*
|
||||
* The time_spec_t provides clock-domain independent time storage,
|
||||
* but can convert fractional seconds to/from clock-domain specific units.
|
||||
*
|
||||
* The fractional seconds are stored as double precision floating point.
|
||||
* This gives the fractional seconds enough precision to unambiguously
|
||||
* specify a clock-tick/sample-count up to rates of several petahertz.
|
||||
*/
|
||||
class time_spec_t : boost::additive<time_spec_t>, boost::totally_ordered<time_spec_t>{
|
||||
public:
|
||||
|
||||
/*!
|
||||
* Get the system time in time_spec_t format.
|
||||
* Uses the highest precision clock available.
|
||||
* \return the system time as a time_spec_t
|
||||
*/
|
||||
static time_spec_t get_system_time(void);
|
||||
|
||||
/*!
|
||||
* Copy constructor
|
||||
*/
|
||||
time_spec_t(const time_spec_t & spec);
|
||||
|
||||
/*!
|
||||
* Create a time_spec_t from a real-valued seconds count.
|
||||
* \param secs the real-valued seconds count (default = 0)
|
||||
*/
|
||||
time_spec_t(double secs = 0);
|
||||
|
||||
/*!
|
||||
* Create a time_spec_t from whole and fractional seconds.
|
||||
* \param full_secs the whole/integer seconds count
|
||||
* \param frac_secs the fractional seconds count (default = 0)
|
||||
*/
|
||||
time_spec_t(time_t full_secs, double frac_secs = 0);
|
||||
|
||||
/*!
|
||||
* Create a time_spec_t from whole seconds and fractional ticks.
|
||||
* Translation from clock-domain specific units.
|
||||
* \param full_secs the whole/integer seconds count
|
||||
* \param tick_count the fractional seconds tick count
|
||||
* \param tick_rate the number of ticks per second
|
||||
*/
|
||||
time_spec_t(time_t full_secs, long tick_count, double tick_rate);
|
||||
|
||||
/*!
|
||||
* Create a time_spec_t from a 64-bit tick count.
|
||||
* Translation from clock-domain specific units.
|
||||
* \param ticks an integer count of ticks
|
||||
* \param tick_rate the number of ticks per second
|
||||
*/
|
||||
static time_spec_t from_ticks(long long ticks, double tick_rate);
|
||||
|
||||
/*!
|
||||
* Convert the fractional seconds to clock ticks.
|
||||
* Translation into clock-domain specific units.
|
||||
* \param tick_rate the number of ticks per second
|
||||
* \return the fractional seconds tick count
|
||||
*/
|
||||
long get_tick_count(double tick_rate) const;
|
||||
|
||||
/*!
|
||||
* Convert the time spec into a 64-bit tick count.
|
||||
* Translation into clock-domain specific units.
|
||||
* \param tick_rate the number of ticks per second
|
||||
* \return an integer number of ticks
|
||||
*/
|
||||
long long to_ticks(const double tick_rate) const;
|
||||
|
||||
/*!
|
||||
* Get the time as a real-valued seconds count.
|
||||
* Note: If this time_spec_t represents an absolute time,
|
||||
* the precision of the fractional seconds may be lost.
|
||||
* \return the real-valued seconds
|
||||
*/
|
||||
double get_real_secs(void) const;
|
||||
|
||||
/*!
|
||||
* Get the whole/integer part of the time in seconds.
|
||||
* \return the whole/integer seconds
|
||||
*/
|
||||
time_t get_full_secs(void) const;
|
||||
|
||||
/*!
|
||||
* Get the fractional part of the time in seconds.
|
||||
* \return the fractional seconds
|
||||
*/
|
||||
double get_frac_secs(void) const;
|
||||
|
||||
//! Implement addable interface
|
||||
time_spec_t &operator+=(const time_spec_t &);
|
||||
|
||||
//! Implement subtractable interface
|
||||
time_spec_t &operator-=(const time_spec_t &);
|
||||
|
||||
//private time storage details
|
||||
private: time_t _full_secs; double _frac_secs;
|
||||
};
|
||||
|
||||
//! Implement equality_comparable interface
|
||||
bool operator==(const time_spec_t &, const time_spec_t &);
|
||||
|
||||
//! Implement less_than_comparable interface
|
||||
bool operator<(const time_spec_t &, const time_spec_t &);
|
||||
|
||||
inline time_t time_spec_t::get_full_secs(void) const{
|
||||
return this->_full_secs;
|
||||
}
|
||||
|
||||
inline double time_spec_t::get_frac_secs(void) const{
|
||||
return this->_frac_secs;
|
||||
}
|
||||
|
||||
} //namespace transceiver
|
||||
} //namespace gr
|
||||
|
||||
#endif /* INCLUDED_TYPES_TIME_SPEC_HPP */
|
||||
Loading…
Reference in New Issue