#include <sdr.h>

Inheritance diagram for leansdr::auto_notch< T >:

Collaboration diagram for leansdr::auto_notch< T >:

Classes
struct	slot

Public Member Functions
	auto_notch (scheduler *sch, pipebuf< complex< T >> &_in, pipebuf< complex< T >> &_out, int _nslots, T _agc_rms_setpoint)

	~auto_notch ()

void	run ()

void	detect ()

void	process ()

Public Member Functions inherited from leansdr::runnable
	runnable (scheduler _sch, const char name)

Public Member Functions inherited from leansdr::runnable_common
	runnable_common (const char *_name)

virtual	~runnable_common ()

virtual void	shutdown ()

Public Attributes
int	decimation

float	k

Public Attributes inherited from leansdr::runnable_common
const char *	name

Private Attributes
cfft_engine< float >	fft

pipereader< complex< T > >	in

pipewriter< complex< T > >	out

int	nslots

slot *	__slots

int	phase

float	gain

T	agc_rms_setpoint

Additional Inherited Members
Protected Attributes inherited from leansdr::runnable
scheduler *	sch

Detailed Description

template<typename T>
struct leansdr::auto_notch< T >

Definition at line 46 of file sdr.h.

Constructor & Destructor Documentation

◆ auto_notch()

template<typename T>

leansdr::auto_notch< T >::auto_notch	(	scheduler *	sch,
		pipebuf< complex< T >> &	_in,
		pipebuf< complex< T >> &	_out,
		int	_nslots,
		T	_agc_rms_setpoint
	)

inline

Definition at line 51 of file sdr.h.

                                     : runnable(sch, "auto_notch"),
                                       decimation(1024 * 4096),
                                       k(0.002), // k(0.01)
                                       fft(4096),
                                       in(_in),
                                       out(_out, fft.n),
                                       nslots(_nslots),
                                       phase(0),
                                       gain(1),
                                       agc_rms_setpoint(_agc_rms_setpoint)
     {
         __slots = new slot[nslots];
 
         for (int s = 0; s < nslots; ++s)
         {
             __slots[s].i = -1;
             __slots[s].expj = new complex<float>[fft.n];
         }
     }

◆ ~auto_notch()

template<typename T>

leansdr::auto_notch< T >::~auto_notch ( )

inline

Definition at line 75 of file sdr.h.

     {
         delete[] __slots;
     }

Member Function Documentation

◆ detect()

template<typename T>

void leansdr::auto_notch< T >::detect ( )

inline

Definition at line 98 of file sdr.h.

Referenced by leansdr::auto_notch< leansdr::f32 >::run().

     {
         complex<T> *pin = in.rd();
         complex<float> *data = new complex<float>[fft.n];
         float m0 = 0, m2 = 0;
 
         for (int i = 0; i < fft.n; ++i)
         {
             data[i].re = pin[i].re;
             data[i].im = pin[i].im;
             m2 += (float)pin[i].re * pin[i].re + (float)pin[i].im * pin[i].im;
             if (gen_abs(pin[i].re) > m0)
                 m0 = gen_abs(pin[i].re);
             if (gen_abs(pin[i].im) > m0)
                 m0 = gen_abs(pin[i].im);
         }
 
         if (agc_rms_setpoint && m2)
         {
             float rms = gen_sqrt(m2 / fft.n);
             if (sch->debug)
                 fprintf(stderr, "(pow %f max %f)", rms, m0);
             float new_gain = agc_rms_setpoint / rms;
             gain = gain * 0.9 + new_gain * 0.1;
         }
 
         fft.inplace(data, true);
         float *amp = new float[fft.n];
 
         for (int i = 0; i < fft.n; ++i)
             amp[i] = hypotf(data[i].re, data[i].im);
 
         for (slot *s = __slots; s < __slots + nslots; ++s)
         {
             int iamax = 0;
 
             for (int i = 0; i < fft.n; ++i)
                 if (amp[i] > amp[iamax])
                     iamax = i;
 
             if (iamax != s->i)
             {
                 if (sch->debug)
                     fprintf(stderr, "%s: slot %d new peak %d -> %d\n", name, (int)(s - __slots), s->i, iamax);
 
                 s->i = iamax;
                 s->estim.re = 0;
                 s->estim.im = 0;
                 s->estt = 0;
 
                 for (int i = 0; i < fft.n; ++i)
                 {
                     float a = 2 * M_PI * s->i * i / fft.n;
                     s->expj[i].re = cosf(a);
                     s->expj[i].im = sinf(a);
                 }
             }
 
             amp[iamax] = 0;
 
             if (iamax - 1 >= 0)
                 amp[iamax - 1] = 0;
 
             if (iamax + 1 < fft.n)
                 amp[iamax + 1] = 0;
         }
 
         delete[] amp;
         delete[] data;
     }

Here is the caller graph for this function:

◆ process()

template<typename T>

void leansdr::auto_notch< T >::process ( )

inline

Definition at line 169 of file sdr.h.

Referenced by leansdr::auto_notch< leansdr::f32 >::run().

     {
         complex<T> *pin = in.rd(), *pend = pin + fft.n, *pout = out.wr();
 
         for (slot *s = __slots; s < __slots + nslots; ++s)
             s->ej = s->expj;
 
         for (; pin < pend; ++pin, ++pout)
         {
             complex<float> out = *pin;
             // TODO Optimize for nslots==1 ?
 
             for (slot *s = __slots; s < __slots + nslots; ++s->ej, ++s)
             {
                 complex<float> bb(pin->re * s->ej->re + pin->im * s->ej->im,
                                   -pin->re * s->ej->im + pin->im * s->ej->re);
                 s->estim.re = bb.re * k + s->estim.re * (1 - k);
                 s->estim.im = bb.im * k + s->estim.im * (1 - k);
                 complex<float> sub(
                     s->estim.re * s->ej->re - s->estim.im * s->ej->im,
                     s->estim.re * s->ej->im + s->estim.im * s->ej->re);
                 out.re -= sub.re;
                 out.im -= sub.im;
             }
 
             pout->re = gain * out.re;
             pout->im = gain * out.im;
         }
     }

Here is the caller graph for this function:

◆ run()

template<typename T>

void leansdr::auto_notch< T >::run ( )

inlinevirtual

Reimplemented from leansdr::runnable_common.

Definition at line 80 of file sdr.h.

     {
         while (in.readable() >= fft.n && out.writable() >= fft.n)
         {
             phase += fft.n;
 
             if (phase >= decimation)
             {
                 phase -= decimation;
                 detect();
             }
 
             process();
             in.read(fft.n);
             out.written(fft.n);
         }
     }