Added timestamping of bursts in the gsm receiver

7 files changed, 478 insertions, 16 deletions

diff --git a/lib/receiver/CMakeLists.txt b/lib/receiver/CMakeLists.txt
index 343d2f8..1c5fd53 100644
--- a/lib/receiver/CMakeLists.txt
+++ b/lib/receiver/CMakeLists.txt
@@ -23,4 +23,6 @@ add_sources(
     receiver_config.cc
     receiver_impl.cc
     viterbi_detector.cc
+    time_spec.cc
+    time_sample_ref.cc
 )
diff --git a/lib/receiver/receiver_impl.cc b/lib/receiver/receiver_impl.cc
index b7c5be2..db7d9dd 100644
--- a/lib/receiver/receiver_impl.cc
+++ b/lib/receiver/receiver_impl.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 */
diff --git a/lib/receiver/receiver_impl.h b/lib/receiver/receiver_impl.h
index 6831bf1..4972b62 100644
--- a/lib/receiver/receiver_impl.h
+++ b/lib/receiver/receiver_impl.h
@@ -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
diff --git a/lib/receiver/time_sample_ref.cc b/lib/receiver/time_sample_ref.cc
new file mode 100644
index 0000000..0cf85ed
--- /dev/null
+++ b/lib/receiver/time_sample_ref.cc
@@ -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
+
diff --git a/lib/receiver/time_sample_ref.h b/lib/receiver/time_sample_ref.h
new file mode 100644
index 0000000..1fecb81
--- /dev/null
+++ b/lib/receiver/time_sample_ref.h
@@ -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
diff --git a/lib/receiver/time_spec.cc b/lib/receiver/time_spec.cc
new file mode 100644
index 0000000..205508d
--- /dev/null
+++ b/lib/receiver/time_spec.cc
@@ -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())
+        ));
+    }
+  }
+}
diff --git a/lib/receiver/time_spec.h b/lib/receiver/time_spec.h
new file mode 100644
index 0000000..cc7f104
--- /dev/null
+++ b/lib/receiver/time_spec.h
@@ -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 */