kopia lustrzana https://github.com/f4exb/sdrangel
259 wiersze
7.7 KiB
C++
259 wiersze
7.7 KiB
C++
/* icfir.c
|
|
|
|
This file is part of a program that implements a Software-Defined Radio.
|
|
|
|
Copyright (C) 2018 Warren Pratt, NR0V
|
|
Copyright (C) 2024 Edouard Griffiths, F4EXB Adapted to SDRangel
|
|
|
|
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 2
|
|
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, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
The author can be reached by email at
|
|
|
|
warren@pratt.one
|
|
|
|
*/
|
|
|
|
#include "comm.hpp"
|
|
#include "fircore.hpp"
|
|
#include "fir.hpp"
|
|
#include "icfir.hpp"
|
|
|
|
namespace WDSP {
|
|
|
|
void ICFIR::calc_icfir (ICFIR *a)
|
|
{
|
|
float* impulse;
|
|
a->scale = 1.0 / (float)(2 * a->size);
|
|
impulse = icfir_impulse (a->nc, a->DD, a->R, a->Pairs, a->runrate, a->cicrate, a->cutoff, a->xtype, a->xbw, 1, a->scale, a->wintype);
|
|
a->p = FIRCORE::create_fircore (a->size, a->in, a->out, a->nc, a->mp, impulse);
|
|
delete[] (impulse);
|
|
}
|
|
|
|
void ICFIR::decalc_icfir (ICFIR *a)
|
|
{
|
|
FIRCORE::destroy_fircore (a->p);
|
|
}
|
|
|
|
ICFIR* ICFIR::create_icfir (
|
|
int run,
|
|
int size,
|
|
int nc,
|
|
int mp,
|
|
float* in,
|
|
float* out,
|
|
int runrate,
|
|
int cicrate,
|
|
int DD,
|
|
int R,
|
|
int Pairs,
|
|
float cutoff,
|
|
int xtype,
|
|
float xbw,
|
|
int wintype
|
|
)
|
|
// run: 0 - no action; 1 - operate
|
|
// size: number of complex samples in an input buffer to the CFIR filter
|
|
// nc: number of filter coefficients
|
|
// mp: minimum phase flag
|
|
// in: pointer to the input buffer
|
|
// out: pointer to the output buffer
|
|
// rate: samplerate
|
|
// DD: differential delay of the CIC to be compensated (usually 1 or 2)
|
|
// R: interpolation factor of CIC
|
|
// Pairs: number of comb-integrator pairs in the CIC
|
|
// cutoff: cutoff frequency
|
|
// xtype: 0 - fourth power transition; 1 - raised cosine transition
|
|
// xbw: width of raised cosine transition
|
|
{
|
|
ICFIR *a = new ICFIR;
|
|
a->run = run;
|
|
a->size = size;
|
|
a->nc = nc;
|
|
a->mp = mp;
|
|
a->in = in;
|
|
a->out = out;
|
|
a->runrate = runrate;
|
|
a->cicrate = cicrate;
|
|
a->DD = DD;
|
|
a->R = R;
|
|
a->Pairs = Pairs;
|
|
a->cutoff = cutoff;
|
|
a->xtype = xtype;
|
|
a->xbw = xbw;
|
|
a->wintype = wintype;
|
|
calc_icfir (a);
|
|
return a;
|
|
}
|
|
|
|
void ICFIR::destroy_icfir (ICFIR *a)
|
|
{
|
|
decalc_icfir (a);
|
|
delete[] (a);
|
|
}
|
|
|
|
void ICFIR::flush_icfir (ICFIR *a)
|
|
{
|
|
FIRCORE::flush_fircore (a->p);
|
|
}
|
|
|
|
void ICFIR::xicfir (ICFIR *a)
|
|
{
|
|
if (a->run)
|
|
FIRCORE::xfircore (a->p);
|
|
else if (a->in != a->out)
|
|
std::copy( a->in, a->in + a->size * 2, a->out);
|
|
}
|
|
|
|
void ICFIR::setBuffers_icfir (ICFIR *a, float* in, float* out)
|
|
{
|
|
decalc_icfir (a);
|
|
a->in = in;
|
|
a->out = out;
|
|
calc_icfir (a);
|
|
}
|
|
|
|
void ICFIR::setSamplerate_icfir (ICFIR *a, int rate)
|
|
{
|
|
decalc_icfir (a);
|
|
a->runrate = rate;
|
|
calc_icfir (a);
|
|
}
|
|
|
|
void ICFIR::setSize_icfir (ICFIR *a, int size)
|
|
{
|
|
decalc_icfir (a);
|
|
a->size = size;
|
|
calc_icfir (a);
|
|
}
|
|
|
|
void ICFIR::setOutRate_icfir (ICFIR *a, int rate)
|
|
{
|
|
decalc_icfir (a);
|
|
a->cicrate = rate;
|
|
calc_icfir (a);
|
|
}
|
|
|
|
float* ICFIR::icfir_impulse (
|
|
int N,
|
|
int DD,
|
|
int R,
|
|
int Pairs,
|
|
float runrate,
|
|
float cicrate,
|
|
float cutoff,
|
|
int xtype,
|
|
float xbw,
|
|
int rtype,
|
|
float scale,
|
|
int wintype
|
|
)
|
|
{
|
|
// N: number of impulse response samples
|
|
// DD: differential delay used in the CIC filter
|
|
// R: interpolation / decimation factor of the CIC
|
|
// Pairs: number of comb-integrator pairs in the CIC
|
|
// runrate: sample rate at which this filter is to run (assumes there may be flat interp. between this filter and the CIC)
|
|
// cicrate: sample rate at interface to CIC
|
|
// cutoff: cutoff frequency
|
|
// xtype: transition type, 0 for 4th-power rolloff, 1 for raised cosine
|
|
// xbw: transition bandwidth for raised cosine
|
|
// rtype: 0 for real output, 1 for complex output
|
|
// scale: scale factor to be applied to the output
|
|
int i, j;
|
|
float tmp, local_scale, ri, mag, fn;
|
|
float* impulse;
|
|
float* A = new float[N]; // (float *) malloc0 (N * sizeof (float));
|
|
float ft = cutoff / cicrate; // normalized cutoff frequency
|
|
int u_samps = (N + 1) / 2; // number of unique samples, OK for odd or even N
|
|
int c_samps = (int)(cutoff / runrate * N) + (N + 1) / 2 - N / 2; // number of unique samples within bandpass, OK for odd or even N
|
|
int x_samps = (int)(xbw / runrate * N); // number of unique samples in transition region, OK for odd or even N
|
|
float offset = 0.5 - 0.5 * (float)((N + 1) / 2 - N / 2); // sample offset from center, OK for odd or even N
|
|
float* xistion = new float[x_samps + 1]; // (float *) malloc0 ((x_samps + 1) * sizeof (float));
|
|
float delta = PI / (float)x_samps;
|
|
float L = cicrate / runrate;
|
|
float phs = 0.0;
|
|
for (i = 0; i <= x_samps; i++)
|
|
{
|
|
xistion[i] = 0.5 * (cos (phs) + 1.0);
|
|
phs += delta;
|
|
}
|
|
if ((tmp = DD * R * sin (PI * ft / R) / sin (PI * DD * ft)) < 0.0) //normalize by peak gain
|
|
tmp = -tmp;
|
|
local_scale = scale / pow (tmp, Pairs);
|
|
if (xtype == 0)
|
|
{
|
|
for (i = 0, ri = offset; i < u_samps; i++, ri += 1.0)
|
|
{
|
|
fn = ri / (L * (float)N);
|
|
if (fn <= ft)
|
|
{
|
|
if (fn == 0.0) tmp = 1.0;
|
|
else if ((tmp = sin (PI * DD * fn) / (DD * R * sin (PI * fn / R))) < 0.0)
|
|
tmp = -tmp;
|
|
mag = pow (tmp, Pairs) * local_scale;
|
|
}
|
|
else
|
|
mag *= (ft * ft * ft * ft) / (fn * fn * fn * fn);
|
|
A[i] = mag;
|
|
}
|
|
}
|
|
else if (xtype == 1)
|
|
{
|
|
for (i = 0, ri = offset; i < u_samps; i++, ri += 1.0)
|
|
{
|
|
fn = ri / (L *(float)N);
|
|
if (i < c_samps)
|
|
{
|
|
if (fn == 0.0) tmp = 1.0;
|
|
else if ((tmp = sin (PI * DD * fn) / (DD * R * sin (PI * fn / R))) < 0.0)
|
|
tmp = -tmp;
|
|
mag = pow (tmp, Pairs) * local_scale;
|
|
A[i] = mag;
|
|
}
|
|
else if ( i >= c_samps && i <= c_samps + x_samps)
|
|
A[i] = mag * xistion[i - c_samps];
|
|
else
|
|
A[i] = 0.0;
|
|
}
|
|
}
|
|
if (N & 1)
|
|
for (i = u_samps, j = 2; i < N; i++, j++)
|
|
A[i] = A[u_samps - j];
|
|
else
|
|
for (i = u_samps, j = 1; i < N; i++, j++)
|
|
A[i] = A[u_samps - j];
|
|
impulse = FIR::fir_fsamp (N, A, rtype, 1.0, wintype);
|
|
// print_impulse ("icfirImpulse.txt", N, impulse, 1, 0);
|
|
delete[] (A);
|
|
delete[] xistion;
|
|
return impulse;
|
|
}
|
|
|
|
/********************************************************************************************************
|
|
* *
|
|
* TXA Properties *
|
|
* *
|
|
********************************************************************************************************/
|
|
|
|
//PORT void
|
|
//SetTXAICFIRRun (int channel, int run)
|
|
//{
|
|
// EnterCriticalSection(&ch[channel].csDSP);
|
|
// txa[channel].icfir.p->run = run;
|
|
// LeaveCriticalSection(&ch[channel].csDSP);
|
|
//}
|
|
|
|
} // namespace WDSP
|