2023-11-19 05:43:20 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Copyright (C) 2015-2019 Edouard Griffiths, F4EXB <f4exb06@gmail.com> //
|
|
|
|
// //
|
|
|
|
// 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 as 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 V3 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/>. //
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////
|
2015-05-12 10:12:13 +00:00
|
|
|
|
|
|
|
#ifndef INCLUDE_GPL_DSP_AGC_H_
|
|
|
|
#define INCLUDE_GPL_DSP_AGC_H_
|
|
|
|
|
2024-04-20 09:51:29 +00:00
|
|
|
#include "dsp/dsptypes.h"
|
2015-05-12 10:12:13 +00:00
|
|
|
#include "movingaverage.h"
|
2018-03-20 12:49:21 +00:00
|
|
|
#include "export.h"
|
2015-05-12 10:12:13 +00:00
|
|
|
|
2018-03-03 19:23:38 +00:00
|
|
|
class SDRBASE_API AGC
|
2015-06-20 07:28:57 +00:00
|
|
|
{
|
|
|
|
public:
|
2017-08-05 21:11:05 +00:00
|
|
|
AGC(int historySize, double R);
|
2015-09-07 21:31:34 +00:00
|
|
|
virtual ~AGC();
|
2015-09-07 07:32:29 +00:00
|
|
|
|
2017-08-05 21:11:05 +00:00
|
|
|
void resize(int historySize, double R);
|
|
|
|
void setOrder(double R) { m_R = R; }
|
2015-09-07 21:31:34 +00:00
|
|
|
Real getValue();
|
2015-09-12 14:34:57 +00:00
|
|
|
Real getAverage();
|
2023-11-30 13:11:36 +00:00
|
|
|
void reset(double R) { m_moving_average.fill(R); }
|
2015-09-07 21:31:34 +00:00
|
|
|
virtual void feed(Complex& ci) = 0;
|
2015-09-07 07:32:29 +00:00
|
|
|
|
2015-09-07 21:31:34 +00:00
|
|
|
protected:
|
2017-08-05 17:08:33 +00:00
|
|
|
double m_u0; //!< AGC factor
|
2017-08-05 22:02:16 +00:00
|
|
|
double m_R; //!< ordered magnitude
|
2017-08-05 17:08:33 +00:00
|
|
|
MovingAverage<double> m_moving_average; //!< Averaging engine. The stack length conditions the smoothness of AGC.
|
2023-12-11 00:12:03 +00:00
|
|
|
int m_historySize; //!< Averaging length (the longer the slower the AGC)
|
2017-08-05 17:08:33 +00:00
|
|
|
int m_count; //!< Samples counter
|
2015-09-07 07:32:29 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2018-03-03 19:23:38 +00:00
|
|
|
class SDRBASE_API MagAGC : public AGC
|
2015-09-07 21:31:34 +00:00
|
|
|
{
|
|
|
|
public:
|
2017-07-24 22:58:16 +00:00
|
|
|
MagAGC(int historySize, double R, double threshold);
|
2015-09-07 21:31:34 +00:00
|
|
|
virtual ~MagAGC();
|
2017-07-27 08:50:41 +00:00
|
|
|
void setSquared(bool squared) { m_squared = squared; }
|
2018-05-06 00:39:39 +00:00
|
|
|
void resize(int historySize, int stepLength, Real R);
|
2017-08-05 21:11:05 +00:00
|
|
|
void setOrder(double R);
|
2015-09-07 21:31:34 +00:00
|
|
|
virtual void feed(Complex& ci);
|
2017-07-24 22:58:16 +00:00
|
|
|
double feedAndGetValue(const Complex& ci);
|
2017-08-05 21:11:05 +00:00
|
|
|
double getMagSq() const { return m_magsq; }
|
2017-07-25 19:21:48 +00:00
|
|
|
void setThreshold(double threshold) { m_threshold = threshold; }
|
2017-07-27 08:50:41 +00:00
|
|
|
void setThresholdEnable(bool enable);
|
2019-06-09 07:25:18 +00:00
|
|
|
void setGate(int gate) { m_gate = gate; m_gateCounter = 0; m_count = 0; }
|
|
|
|
void setStepDownDelay(int stepDownDelay) { m_stepDownDelay = stepDownDelay; m_gateCounter = 0; m_count = 0; }
|
2018-04-22 07:37:34 +00:00
|
|
|
int getStepDownDelay() const { return m_stepDownDelay; }
|
2018-05-06 00:39:39 +00:00
|
|
|
float getStepValue() const;
|
2019-05-07 00:50:05 +00:00
|
|
|
void setHardLimiting(bool hardLimiting) { m_hardLimiting = hardLimiting; }
|
2023-12-01 16:24:28 +00:00
|
|
|
void resetStepCounters() { m_stepUpCounter = 0; m_stepDownCounter = 0; }
|
2018-04-22 07:37:34 +00:00
|
|
|
|
2015-10-04 04:26:06 +00:00
|
|
|
private:
|
2017-07-27 08:50:41 +00:00
|
|
|
bool m_squared; //!< use squared magnitude (power) to compute AGC value
|
|
|
|
double m_magsq; //!< current squared magnitude (power)
|
2017-07-26 06:39:20 +00:00
|
|
|
double m_threshold; //!< squelch on magsq average
|
2017-07-27 08:50:41 +00:00
|
|
|
bool m_thresholdEnable; //!< enable squelch on power threshold
|
2017-07-26 06:39:20 +00:00
|
|
|
int m_gate; //!< power threshold gate in number of samples
|
|
|
|
int m_stepLength; //!< transition step length in number of samples
|
2017-07-26 14:23:34 +00:00
|
|
|
double m_stepDelta; //!< transition step unit by sample
|
2017-07-26 06:39:20 +00:00
|
|
|
int m_stepUpCounter; //!< step up transition samples counter
|
|
|
|
int m_stepDownCounter; //!< step down transition samples counter
|
|
|
|
int m_gateCounter; //!< threshold gate samples counter
|
2017-08-05 17:08:33 +00:00
|
|
|
int m_stepDownDelay; //!< delay in samples before cutoff (release)
|
2019-05-07 00:50:05 +00:00
|
|
|
bool m_hardLimiting; //!< hard limit multiplier so that resulting sample magnitude does not exceed 1.0
|
|
|
|
|
|
|
|
double hardLimiter(double multiplier, double magsq);
|
2015-09-07 21:31:34 +00:00
|
|
|
};
|
2015-06-20 07:28:57 +00:00
|
|
|
|
2018-02-03 16:06:16 +00:00
|
|
|
template<uint32_t AvgSize>
|
2015-09-07 21:31:34 +00:00
|
|
|
class SimpleAGC
|
2015-06-20 07:28:57 +00:00
|
|
|
{
|
|
|
|
public:
|
2018-02-15 23:43:21 +00:00
|
|
|
SimpleAGC(Real initial, Real cutoff=0, Real clip=0) :
|
2018-02-03 16:06:16 +00:00
|
|
|
m_cutoff(cutoff),
|
2018-02-15 23:43:21 +00:00
|
|
|
m_clip(clip),
|
|
|
|
m_moving_average(AvgSize, initial)
|
|
|
|
{
|
|
|
|
}
|
2015-06-20 07:28:57 +00:00
|
|
|
|
2018-02-15 23:43:21 +00:00
|
|
|
void resize(Real initial, Real cutoff=0, Real clip=0)
|
2017-05-12 14:38:58 +00:00
|
|
|
{
|
2018-02-03 16:06:16 +00:00
|
|
|
m_cutoff = cutoff;
|
|
|
|
m_clip = clip;
|
2018-02-15 23:43:21 +00:00
|
|
|
m_moving_average.resize(AvgSize, initial);
|
2017-05-12 14:38:58 +00:00
|
|
|
}
|
|
|
|
|
2018-05-13 20:30:50 +00:00
|
|
|
void resizeNew(uint32_t newSize, Real initial, Real cutoff=0, Real clip=0)
|
|
|
|
{
|
|
|
|
m_cutoff = cutoff;
|
|
|
|
m_clip = clip;
|
|
|
|
m_moving_average.resize(newSize, initial);
|
|
|
|
}
|
|
|
|
|
2018-02-15 23:43:21 +00:00
|
|
|
void fill(double value)
|
|
|
|
{
|
|
|
|
m_moving_average.fill(value);
|
|
|
|
}
|
|
|
|
|
2015-06-20 07:28:57 +00:00
|
|
|
Real getValue()
|
|
|
|
{
|
2018-02-15 23:43:21 +00:00
|
|
|
if ((Real) m_moving_average.average() > m_clip) {
|
|
|
|
return (Real) m_moving_average.average();
|
|
|
|
} else {
|
2018-02-03 16:06:16 +00:00
|
|
|
return m_clip;
|
|
|
|
}
|
2015-09-07 21:31:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void feed(Real value)
|
|
|
|
{
|
2018-02-15 23:43:21 +00:00
|
|
|
if (value > m_cutoff) {
|
|
|
|
m_moving_average.feed(value);
|
2018-02-03 16:06:16 +00:00
|
|
|
}
|
2015-09-07 21:31:34 +00:00
|
|
|
}
|
|
|
|
|
2015-06-20 07:28:57 +00:00
|
|
|
private:
|
2015-09-07 21:31:34 +00:00
|
|
|
Real m_cutoff; // consider samples only above this level
|
|
|
|
Real m_clip; // never go below this level
|
2018-02-15 23:43:21 +00:00
|
|
|
MovingAverage<double> m_moving_average; // Averaging engine. The stack length conditions the smoothness of AGC.
|
|
|
|
//MovingAverageUtil<Real, double, AvgSize> m_moving_average;
|
2015-05-12 10:12:13 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#endif /* INCLUDE_GPL_DSP_AGC_H_ */
|