/* -*- c++ -*- */
/*
* Copyright (C) 2017 Free Software Foundation, Inc.
*
* This file is part of GNU Radio
*
* GNU Radio 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.
*
* GNU Radio 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 file; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street,
* Boston, MA 02110-1301, USA.
*/
#ifndef INCLUDED_DIGITAL_TIMING_ERROR_DETECTOR_H
#define INCLUDED_DIGITAL_TIMING_ERROR_DETECTOR_H
#include <gnuradio/gr_complex.h>
#include <gnuradio/digital/timing_error_detector_type.h>
#include <gnuradio/digital/constellation.h>
#include <deque>
namespace gr {
namespace digital {
/*!
* \brief Base class for the composite symbol clock timing error
* detector object used by the symbol_synchronizer_xx blocks.
* \ingroup internal
*
* \details
* This is the base class for the symbol clock timing error detector
* object used by the symbol_synchronizer_xx blocks to provide a
* user selectable timing error detector type.
*
* This base class provides the enumeration type for the available
* types of timing error detectors.
*
* This base class also provides most of the methods update, manage, and
* store the data points required to compute the symbol clock timing error,
* and the timing error result itself.
*
* The derived classes only have to provide the simple functions
* to actually compute the timing error.
*/
class timing_error_detector
{
public:
/*!
* \brief Create a timing error detector object of the specified
* type
* \param type The type/algorithm to use for the timing error detector
* \param constellation A constellation to be used as a decision slicer
* for decision directed timing error detector
* algorithms
*/
static timing_error_detector *make(enum ted_type type,
constellation_sptr constellation =
constellation_sptr());
virtual ~timing_error_detector() {};
/*!
* \brief Return the number of input samples per symbol this timing
* error detector algorithm requires.
*/
virtual int inputs_per_symbol() { return d_inputs_per_symbol; }
/*!
* \brief Provide a complex input sample to the TED algorithm
* \param x the input sample
* \param dx the derivative at the input sample, if required by the
* timinig error detector algorithm
*/
virtual void input(const gr_complex &x,
const gr_complex &dx = gr_complex(0.0f, 0.0f));
/*!
* \brief Provide a float input sample to the TED algorithm
* \param x the input sample
* \param dx the derivative at the input sample, if required by the
* timinig error detector algorithm
*/
virtual void input(float x,
float dx = 0.0f);
/*!
* \brief Return if this timing error detector algorithm requires a
* look-ahead input sample to be input to produce a new error estimate
* for the symbol sampling instant.
*/
virtual bool needs_lookahead() { return d_needs_lookahead; }
/*!
* \brief Provide a complex input lookahead sample to the TED algorithm
* \param x the input lookahead sample
* \param dx the derivative at the input lookahead sample, if required
* by the timinig error detector algorithm
*/
virtual void input_lookahead(const gr_complex &x,
const gr_complex &dx =
gr_complex(0.0f, 0.0f));
/*!
* \brief Provide a float input lookahead sample to the TED algorithm
* \param x the input lookahead sample
* \param dx the derivative at the input lookahead sample, if required
* by the timinig error detector algorithm
*/
virtual void input_lookahead(float x,
float dx = 0.0f);
/*!
* \brief Return if this timing error detector algorithm requires
* derivative input samples in addition to normal input samples.
*/
virtual bool needs_derivative() { return d_needs_derivative; }
/*!
* \brief Return the current symbol timing error estimate
*/
virtual float error() { return d_error; }
/*!
* \brief Revert the timing error detector processing state back one
* step.
* \param preserve_error If true, don't revert the error estimate.
*/
virtual void revert(bool preserve_error = false);
/*!
* \brief Reset the timing error detector
*/
virtual void sync_reset();
private:
enum ted_type d_type;
protected:
/*!
* \brief Create a timing error detector abstract base class object
* object
* \param type The type/algorithm to use for the timing error detector
* \param inputs_per_symbol The input samples per symbol this TED
* algorithm requires
* \param error_computation_depth The number of input samples this TED
* algorithm needs to compute the error
* \param needs_lookahead True if this TED algorithm needs a lookahead
* input sample to compute the error for the
* symbol sampling instant
* \param needs_derivative True if this TED algorithm needs a derivative
* input sample in addition to the normal input
* sample
* \param constellation A constellation to be used as a decision slicer
* for decision directed timing error detector
* algorithms
*/
timing_error_detector(enum ted_type type,
int inputs_per_symbol,
int error_computation_depth,
bool needs_lookahead = false,
bool needs_derivative = false,
constellation_sptr constellation =
constellation_sptr());
/*!
* \brief Advance the TED input clock, so the input() methods will
* compute the TED error term at the proper symbol sampling instant.
*/
void advance_input_clock() {
d_input_clock = (d_input_clock + 1) % d_inputs_per_symbol;
}
/*!
* \brief Revert the TED input clock one step
*/
void revert_input_clock()
{
if (d_input_clock == 0)
d_input_clock = d_inputs_per_symbol - 1;
else
d_input_clock--;
}
/*!
* \brief Reset the TED input clock, so the next input clock advance
* corresponds to a symbol sampling instant.
*/
void sync_reset_input_clock() {
d_input_clock = d_inputs_per_symbol - 1;
}
/*!
* \brief Convert the soft symbol sample into a hard symbol decision.
* \param x the soft input symbol sample
*/
gr_complex slice(const gr_complex &x);
/*!
* \brief Compute the TED error term for complex input samples
*/
virtual float compute_error_cf() = 0;
/*!
* \brief Compute the TED error term for float input samples
*/
virtual float compute_error_ff() = 0;
constellation_sptr d_constellation;
float d_error;
float d_prev_error;
int d_inputs_per_symbol;
int d_input_clock;
int d_error_depth;
std::deque<gr_complex> d_input;
std::deque<gr_complex> d_decision;
std::deque<gr_complex> d_input_derivative;
bool d_needs_lookahead;
bool d_needs_derivative;
};
/*!
* \brief Mueller and Müller (M&M) timing error detector algorithm class
* \ingroup internal
*
* \details
* This is the Mueller and Müller (M&M) timing error detector algorithm
* class. It is a decision directed timing error detector, and requires
* an input slicer constellation to make decisions.
*
* See equation (49) of:
* Mueller, Kurt H., Müller, Markus, "Timing Recovery in Digital
* Synchronous Data Receivers", _IEEE_Transactions_on_Communications_,
* Vol. COM-24, No. 5, May 1976, pp. 516-531
*/
class ted_mueller_and_muller : public timing_error_detector
{
public:
/*!
* \brief Create a Mueller and Müller (M&M) timing error detector
* \param constellation A constellation to be used as a decision slicer
*/
ted_mueller_and_muller(constellation_sptr constellation)
: timing_error_detector(TED_MUELLER_AND_MULLER,
1, 2, false, false, constellation)
{}
~ted_mueller_and_muller() {};
private:
float compute_error_cf();
float compute_error_ff();
};
/*!
* \brief Modified Mueller and Müller (M&M) timing error detector algorithm
* class
* \ingroup internal
*
* \details
* This is the modified Mueller and Müller (M&M) timing error detector
* algorithm class. It is a decision directed timing error detector, and
* requires an input slicer constellation to make decisions.
*
* The modification of the standard M&M TED is done to remove
* self-noise that is present in the standard M&M TED.
*
* See:
* G. R. Danesfahani, T.G. Jeans, "Optimisation of modified Mueller
* and Muller algorithm," Electronics Letters, Vol. 31, no. 13, 22
* June 1995, pp. 1032 - 1033.
*/
class ted_mod_mueller_and_muller : public timing_error_detector
{
public:
/*!
* \brief Create a modified Mueller and Müller (M&M) timing error
* detector
* \param constellation A constellation to be used as a decision slicer
*/
ted_mod_mueller_and_muller(constellation_sptr constellation)
: timing_error_detector(TED_MOD_MUELLER_AND_MULLER,
1, 3, false, false, constellation)
{}
~ted_mod_mueller_and_muller() {};
private:
float compute_error_cf();
float compute_error_ff();
};
/*!
* \brief Zero Crossing timing error detector algorithm class
* \ingroup internal
*
* \details
* This is the Zero Crossing timing error detector algorithm class.
* It is a decision directed timing error detector, and
* requires an input slicer constellation to make decisions.
*/
class ted_zero_crossing : public timing_error_detector
{
public:
/*!
* \brief Create a Zero Crossing timing error detector
* \param constellation A constellation to be used as a decision slicer
*/
ted_zero_crossing(constellation_sptr constellation)
: timing_error_detector(TED_ZERO_CROSSING,
2, 3, false, false, constellation)
{}
~ted_zero_crossing() {};
private:
float compute_error_cf();
float compute_error_ff();
};
/*!
* \brief Gardner timing error detector algorithm class
* \ingroup internal
*
* \details
* This is the Gardner timing error detector algorithm class.
*
* See:
* F.M. Gardner, “A BPSK/QPSK Timing Error Detector for Sampled Receivers”,
* IEEE Trans., COM-34, (5), 1988, pp. 423 – 429.
*/
class ted_gardner : public timing_error_detector
{
public:
/*!
* \brief Create a Gardner timing error detector
*/
ted_gardner()
: timing_error_detector(TED_GARDNER,
2, 3, false, false,
constellation_sptr())
{}
~ted_gardner() {};
private:
float compute_error_cf();
float compute_error_ff();
};
/*!
* \brief Early-Late timing error detector algorithm class
* \ingroup internal
*
* \details
* This is the Early-Late timing error detector algorithm class.
* It requires a lookahead sample to compute the symbol timing error
* at the symbol sampling instant.
*/
class ted_early_late : public timing_error_detector
{
public:
/*!
* \brief Create a Early-Late timing error detector
*/
ted_early_late()
: timing_error_detector(TED_EARLY_LATE,
2, 2, true, false,
constellation_sptr())
{}
~ted_early_late() {};
private:
float compute_error_cf();
float compute_error_ff();
};
/*!
* \brief Generalized MSK timing error detector algorithm class
* \ingroup internal
*
* \details
* This is the Generalized MSK timing error detector algorithm class.
* It operates on the CPM MSK signal directly and not the FM pulses.
*
* See:
* A.N. D'Andrea, U. Mengali, R. Reggiannini, "A digital approach to clock
* recovery in generalized minimum shift keying", IEEE Transactions on
* Vehicular Technology, Vol. 39, Issue 3, August 1990, pp. 227-234
*/
class ted_generalized_msk : public timing_error_detector
{
public:
/*!
* \brief Create a Generalized MSK timing error detector
*/
ted_generalized_msk()
: timing_error_detector(TED_DANDREA_AND_MENGALI_GEN_MSK,
2, 4, false, false, constellation_sptr())
{}
~ted_generalized_msk() {};
private:
float compute_error_cf();
float compute_error_ff();
};
/*!
* \brief Gaussian MSK timing error detector algorithm class
* \ingroup internal
*
* \details
* This is the Gaussian MSK timing error detector algorithm class.
* It operates on the CPM MSK signal directly and not the FM pulses.
*
* See:
* U. Mengali, A.N. D'Andrea, _Synchronization_Techniques_for_Digital_
* Receviers_, New York, Plenum Press 1997
*/
class ted_gaussian_msk : public timing_error_detector
{
public:
/*!
* \brief Create a Generalized MSK timing error detector
*/
ted_gaussian_msk()
: timing_error_detector(TED_MENGALI_AND_DANDREA_GMSK,
2, 4, false, false, constellation_sptr())
{}
~ted_gaussian_msk() {};
private:
float compute_error_cf();
float compute_error_ff();
};
/*!
* \brief Signal times Slope Maximum Likelyhood solution approximation
* timing error detector algorithm class
* \ingroup internal
*
* \details
* This is the Signal times Slope Maximum Likelyhood solution approximation
* timing error detector algorithm class. This approximation is good for
* small signals (< 1.0) and/or situations with low SNR.
*
* See equation (5) and the 2 following paragraphs of:
* Fredric J. Harris, Michael Rice, "Multirate Digital Filters for
* Symbol Timing Synchronization in Software Defined Radios",
* _IEEE_Journal_on_Selected_Areas_in_Communications_, Vol. 19, No. 12,
* December 2001, pp. 2346 - 2357
*/
class ted_signal_times_slope_ml : public timing_error_detector
{
public:
/*!
* \brief Create a Signal times Slope Maximum Likelyhood solution
* approximation timing error detector
*/
ted_signal_times_slope_ml()
: timing_error_detector(TED_SIGNAL_TIMES_SLOPE_ML,
1, 1, false, true, constellation_sptr())
{}
~ted_signal_times_slope_ml() {};
private:
float compute_error_cf();
float compute_error_ff();
};
/*!
* \brief Signum times Slope Maximum Likelyhood solution approximation
* timing error detector algorithm class
* \ingroup internal
*
* \details
* This is the Signum times Slope Maximum Likelyhood solution approximation
* timing error detector algorithm class. This approximation is good for
* large signals (> 1.0) and/or situations with high SNR.
*
* See equation (5) and the 2 following paragraphs of:
* Fredric J. Harris, Michael Rice, "Multirate Digital Filters for
* Symbol Timing Synchronization in Software Defined Radios",
* _IEEE_Journal_on_Selected_Areas_in_Communications_, Vol. 19, No. 12,
* December 2001, pp. 2346 - 2357
*/
class ted_signum_times_slope_ml : public timing_error_detector
{
public:
/*!
* \brief Create a Signum times Slope Maximum Likelyhood solution
* approximation timing error detector
*/
ted_signum_times_slope_ml()
: timing_error_detector(TED_SIGNUM_TIMES_SLOPE_ML,
1, 1, false, true, constellation_sptr())
{}
~ted_signum_times_slope_ml() {};
private:
float compute_error_cf();
float compute_error_ff();
};
} /* namespace digital */
} /* namespace gr */
#endif /* INCLUDED_DIGITAL_TIMING_ERROR_DETECTOR_H */