mirror of
https://github.com/f4exb/sdrangel.git
synced 2024-11-25 09:18:54 -05:00
646 lines
21 KiB
C++
646 lines
21 KiB
C++
/* nobII.c
|
|
|
|
This file is part of a program that implements a Software-Defined Radio.
|
|
|
|
Copyright (C) 2014 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@wpratt.com
|
|
|
|
*/
|
|
|
|
#include "comm.hpp"
|
|
|
|
#define MAX_ADV_SLEW_TIME (0.01) // Slew time
|
|
#define MAX_ADV_TIME (0.01) // Lead time
|
|
#define MAX_HANG_SLEW_TIME (0.01) // Slew time
|
|
#define MAX_HANG_TIME (0.01) // Lag time
|
|
#define MAX_SEQ_TIME (0.025)
|
|
#define MAX_SAMPLERATE (1536000.0)
|
|
|
|
#include "nob.hpp"
|
|
|
|
namespace WDSP {
|
|
|
|
void NOB::init()
|
|
{
|
|
int i;
|
|
double coef;
|
|
|
|
adv_slew_count = (int)(advslewtime * samplerate);
|
|
adv_count = (int)(advtime * samplerate);
|
|
hang_count = (int)(hangtime * samplerate);
|
|
hang_slew_count = (int)(hangslewtime * samplerate);
|
|
max_imp_seq = (int)(max_imp_seq_time * samplerate);
|
|
backmult = exp (-1.0 / (samplerate * backtau));
|
|
ombackmult = 1.0 - backmult;
|
|
|
|
if (adv_slew_count > 0)
|
|
{
|
|
coef = PI / (adv_slew_count + 1);
|
|
|
|
for (i = 0; i < adv_slew_count; i++)
|
|
awave[i] = 0.5 * cos ((i + 1) * coef);
|
|
}
|
|
|
|
if (hang_slew_count > 0)
|
|
{
|
|
coef = PI / hang_slew_count;
|
|
|
|
for (i = 0; i < hang_slew_count; i++)
|
|
hwave[i] = 0.5 * cos (i * coef);
|
|
}
|
|
|
|
flush();
|
|
}
|
|
|
|
NOB::NOB (
|
|
int _run,
|
|
int _buffsize,
|
|
float* _in,
|
|
float* _out,
|
|
double _samplerate,
|
|
int _mode,
|
|
double _advslewtime,
|
|
double _advtime,
|
|
double _hangslewtime,
|
|
double _hangtime,
|
|
double _max_imp_seq_time,
|
|
double _backtau,
|
|
double _threshold
|
|
) :
|
|
run(_run),
|
|
buffsize(_buffsize),
|
|
in(_in),
|
|
out(_out),
|
|
samplerate(_samplerate),
|
|
mode(_mode),
|
|
advslewtime(_advslewtime),
|
|
advtime(_advtime),
|
|
hangslewtime(_hangslewtime),
|
|
hangtime(_hangtime),
|
|
max_imp_seq_time(_max_imp_seq_time),
|
|
backtau(_backtau),
|
|
threshold(_threshold)
|
|
{
|
|
dline_size = (int)(MAX_SAMPLERATE * (
|
|
MAX_ADV_SLEW_TIME +
|
|
MAX_ADV_TIME +
|
|
MAX_HANG_SLEW_TIME +
|
|
MAX_HANG_TIME +
|
|
MAX_SEQ_TIME ) + 2);
|
|
dline.resize(dline_size * 2);
|
|
imp.resize(dline_size);
|
|
awave.resize((int)(MAX_ADV_SLEW_TIME * MAX_SAMPLERATE + 1));
|
|
hwave.resize((int)(MAX_HANG_SLEW_TIME * MAX_SAMPLERATE + 1));
|
|
|
|
filterlen = 10;
|
|
bfbuff.resize(filterlen * 2);
|
|
ffbuff.resize(filterlen * 2);
|
|
fcoefs.resize(filterlen);
|
|
fcoefs[0] = 0.308720593;
|
|
fcoefs[1] = 0.216104415;
|
|
fcoefs[2] = 0.151273090;
|
|
fcoefs[3] = 0.105891163;
|
|
fcoefs[4] = 0.074123814;
|
|
fcoefs[5] = 0.051886670;
|
|
fcoefs[6] = 0.036320669;
|
|
fcoefs[7] = 0.025424468;
|
|
fcoefs[8] = 0.017797128;
|
|
fcoefs[9] = 0.012457989;
|
|
|
|
init();
|
|
}
|
|
|
|
void NOB::flush()
|
|
{
|
|
out_idx = 0;
|
|
scan_idx = out_idx + adv_slew_count + adv_count + 1;
|
|
in_idx = scan_idx + max_imp_seq + hang_count + hang_slew_count + filterlen;
|
|
state = 0;
|
|
overflow = 0;
|
|
avg = 1.0;
|
|
bfb_in_idx = filterlen - 1;
|
|
ffb_in_idx = filterlen - 1;
|
|
std::fill(dline.begin(), dline.end(), 0);
|
|
std::fill(imp.begin(), imp.end(), 0);
|
|
std::fill(bfbuff.begin(), bfbuff.end(), 0);
|
|
std::fill(ffbuff.begin(), ffbuff.end(), 0);
|
|
}
|
|
|
|
void NOB::execute()
|
|
{
|
|
double scale;
|
|
double mag;
|
|
int bf_idx;
|
|
int ff_idx;
|
|
int lidx, tidx;
|
|
int i, j, k;
|
|
int bfboutidx;
|
|
int ffboutidx;
|
|
int hcount;
|
|
int len;
|
|
int ffcount;
|
|
int staydown;
|
|
|
|
if (run)
|
|
{
|
|
for (i = 0; i < buffsize; i++)
|
|
{
|
|
dline[2 * in_idx + 0] = in[2 * i + 0];
|
|
dline[2 * in_idx + 1] = in[2 * i + 1];
|
|
mag = sqrt(dline[2 * in_idx + 0] * dline[2 * in_idx + 0] + dline[2 * in_idx + 1] * dline[2 * in_idx + 1]);
|
|
avg = backmult * avg + ombackmult * mag;
|
|
|
|
if (mag > (avg * threshold))
|
|
imp[in_idx] = 1;
|
|
else
|
|
imp[in_idx] = 0;
|
|
|
|
if ((bf_idx = out_idx + adv_slew_count) >= dline_size)
|
|
bf_idx -= dline_size;
|
|
|
|
if (imp[bf_idx] == 0)
|
|
{
|
|
if (++bfb_in_idx == filterlen)
|
|
bfb_in_idx -= filterlen;
|
|
|
|
bfbuff[2 * bfb_in_idx + 0] = dline[2 * bf_idx + 0];
|
|
bfbuff[2 * bfb_in_idx + 1] = dline[2 * bf_idx + 1];
|
|
}
|
|
|
|
switch (state)
|
|
{
|
|
case 0: // normal output & impulse setup
|
|
{
|
|
out[2 * i + 0] = dline[2 * out_idx + 0];
|
|
out[2 * i + 1] = dline[2 * out_idx + 1];
|
|
Ilast = dline[2 * out_idx + 0];
|
|
Qlast = dline[2 * out_idx + 1];
|
|
|
|
if (imp[scan_idx] > 0)
|
|
{
|
|
time = 0;
|
|
|
|
if (adv_slew_count > 0)
|
|
state = 1;
|
|
else if (adv_count > 0)
|
|
state = 2;
|
|
else
|
|
state = 3;
|
|
|
|
tidx = scan_idx;
|
|
blank_count = 0;
|
|
|
|
do
|
|
{
|
|
len = 0;
|
|
hcount = 0;
|
|
|
|
while ((imp[tidx] > 0 || hcount > 0) && blank_count < max_imp_seq)
|
|
{
|
|
blank_count++;
|
|
if (hcount > 0)
|
|
hcount--;
|
|
if (imp[tidx] > 0)
|
|
hcount = hang_count + hang_slew_count;
|
|
if (++tidx >= dline_size)
|
|
tidx -= dline_size;
|
|
}
|
|
|
|
j = 1;
|
|
len = 0;
|
|
lidx = tidx;
|
|
|
|
while (j <= adv_slew_count + adv_count && len == 0)
|
|
{
|
|
if (imp[lidx] == 1)
|
|
{
|
|
len = j;
|
|
tidx = lidx;
|
|
}
|
|
|
|
if (++lidx >= dline_size)
|
|
lidx -= dline_size;
|
|
|
|
j++;
|
|
}
|
|
|
|
if((blank_count += len) > max_imp_seq)
|
|
{
|
|
blank_count = max_imp_seq;
|
|
overflow = 1;
|
|
break;
|
|
}
|
|
}
|
|
while (len != 0);
|
|
|
|
if (overflow == 0)
|
|
{
|
|
blank_count -= hang_slew_count;
|
|
Inext = dline[2 * tidx + 0];
|
|
Qnext = dline[2 * tidx + 1];
|
|
|
|
if (mode == 1 || mode == 2 || mode == 4)
|
|
{
|
|
bfboutidx = bfb_in_idx;
|
|
I1 = 0.0;
|
|
Q1 = 0.0;
|
|
|
|
for (k = 0; k < filterlen; k++)
|
|
{
|
|
I1 += fcoefs[k] * bfbuff[2 * bfboutidx + 0];
|
|
Q1 += fcoefs[k] * bfbuff[2 * bfboutidx + 1];
|
|
|
|
if (--bfboutidx < 0)
|
|
bfboutidx += filterlen;
|
|
}
|
|
}
|
|
|
|
if (mode == 2 || mode == 3 || mode == 4)
|
|
{
|
|
if ((ff_idx = scan_idx + blank_count) >= dline_size)
|
|
ff_idx -= dline_size;
|
|
|
|
ffcount = 0;
|
|
|
|
while (ffcount < filterlen)
|
|
{
|
|
if (imp[ff_idx] == 0)
|
|
{
|
|
if (++ffb_in_idx == filterlen)
|
|
ffb_in_idx -= filterlen;
|
|
|
|
ffbuff[2 * ffb_in_idx + 0] = dline[2 * ff_idx + 0];
|
|
ffbuff[2 * ffb_in_idx + 1] = dline[2 * ff_idx + 1];
|
|
++ffcount;
|
|
}
|
|
|
|
if (++ff_idx >= dline_size)
|
|
ff_idx -= dline_size;
|
|
}
|
|
|
|
if ((ffboutidx = ffb_in_idx + 1) >= filterlen)
|
|
ffboutidx -= filterlen;
|
|
|
|
I2 = 0.0;
|
|
Q2 = 0.0;
|
|
|
|
for (k = 0; k < filterlen; k++)
|
|
{
|
|
I2 += fcoefs[k] * ffbuff[2 * ffboutidx + 0];
|
|
Q2 += fcoefs[k] * ffbuff[2 * ffboutidx + 1];
|
|
|
|
if (++ffboutidx >= filterlen)
|
|
ffboutidx -= filterlen;
|
|
}
|
|
}
|
|
|
|
switch (mode)
|
|
{
|
|
case 0: // zero
|
|
deltaI = 0.0;
|
|
deltaQ = 0.0;
|
|
I = 0.0;
|
|
Q = 0.0;
|
|
break;
|
|
case 1: // sample-hold
|
|
deltaI = 0.0;
|
|
deltaQ = 0.0;
|
|
I = I1;
|
|
Q = Q1;
|
|
break;
|
|
case 2: // mean-hold
|
|
deltaI = 0.0;
|
|
deltaQ = 0.0;
|
|
I = 0.5 * (I1 + I2);
|
|
Q = 0.5 * (Q1 + Q2);
|
|
break;
|
|
case 3: // hold-sample
|
|
deltaI = 0.0;
|
|
deltaQ = 0.0;
|
|
I = I2;
|
|
Q = Q2;
|
|
break;
|
|
case 4: // linear interpolation
|
|
deltaI = (I2 - I1) / (adv_count + blank_count);
|
|
deltaQ = (Q2 - Q1) / (adv_count + blank_count);
|
|
I = I1;
|
|
Q = Q1;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (adv_slew_count > 0)
|
|
{
|
|
state = 5;
|
|
}
|
|
else
|
|
{
|
|
state = 6;
|
|
time = 0;
|
|
blank_count += adv_count + filterlen;
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case 1: // slew output in advance of blanking period
|
|
{
|
|
scale = 0.5 + awave[time];
|
|
out[2 * i + 0] = Ilast * scale + (1.0 - scale) * I;
|
|
out[2 * i + 1] = Qlast * scale + (1.0 - scale) * Q;
|
|
|
|
if (++time == adv_slew_count)
|
|
{
|
|
time = 0;
|
|
|
|
if (adv_count > 0)
|
|
state = 2;
|
|
else
|
|
state = 3;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case 2: // initial advance period
|
|
{
|
|
out[2 * i + 0] = I;
|
|
out[2 * i + 1] = Q;
|
|
I += deltaI;
|
|
Q += deltaQ;
|
|
|
|
if (++time == adv_count)
|
|
{
|
|
state = 3;
|
|
time = 0;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case 3: // impulse & hang period
|
|
{
|
|
out[2 * i + 0] = I;
|
|
out[2 * i + 1] = Q;
|
|
I += deltaI;
|
|
Q += deltaQ;
|
|
|
|
if (++time == blank_count)
|
|
{
|
|
if (hang_slew_count > 0)
|
|
{
|
|
state = 4;
|
|
time = 0;
|
|
}
|
|
else
|
|
{
|
|
state = 0;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case 4: // slew output after blanking period
|
|
{
|
|
scale = 0.5 - hwave[time];
|
|
out[2 * i + 0] = Inext * scale + (1.0 - scale) * I;
|
|
out[2 * i + 1] = Qnext * scale + (1.0 - scale) * Q;
|
|
|
|
if (++time == hang_slew_count)
|
|
state = 0;
|
|
|
|
break;
|
|
}
|
|
|
|
case 5:
|
|
{
|
|
scale = 0.5 + awave[time];
|
|
out[2 * i + 0] = Ilast * scale;
|
|
out[2 * i + 1] = Qlast * scale;
|
|
|
|
if (++time == adv_slew_count)
|
|
{
|
|
state = 6;
|
|
time = 0;
|
|
blank_count += adv_count + filterlen;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case 6:
|
|
{
|
|
out[2 * i + 0] = 0.0;
|
|
out[2 * i + 1] = 0.0;
|
|
|
|
if (++time == blank_count)
|
|
state = 7;
|
|
|
|
break;
|
|
}
|
|
|
|
case 7:
|
|
{
|
|
out[2 * i + 0] = 0.0;
|
|
out[2 * i + 1] = 0.0;
|
|
staydown = 0;
|
|
time = 0;
|
|
|
|
if ((tidx = scan_idx + hang_slew_count + hang_count) >= dline_size)
|
|
tidx -= dline_size;
|
|
|
|
while (time++ <= adv_count + adv_slew_count + hang_slew_count + hang_count) // CHECK EXACT COUNTS!!!!!!!!!!!!!!!!!!!!!!!
|
|
{
|
|
if (imp[tidx] == 1) staydown = 1;
|
|
if (--tidx < 0) tidx += dline_size;
|
|
}
|
|
|
|
if (staydown == 0)
|
|
{
|
|
if (hang_count > 0)
|
|
{
|
|
state = 8;
|
|
time = 0;
|
|
}
|
|
else if (hang_slew_count > 0)
|
|
{
|
|
state = 9;
|
|
time = 0;
|
|
|
|
if ((tidx = scan_idx + hang_slew_count + hang_count - adv_count - adv_slew_count) >= dline_size)
|
|
tidx -= dline_size;
|
|
|
|
if (tidx < 0)
|
|
tidx += dline_size;
|
|
|
|
Inext = dline[2 * tidx + 0];
|
|
Qnext = dline[2 * tidx + 1];
|
|
}
|
|
else
|
|
{
|
|
state = 0;
|
|
overflow = 0;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case 8:
|
|
{
|
|
out[2 * i + 0] = 0.0;
|
|
out[2 * i + 1] = 0.0;
|
|
|
|
if (++time == hang_count)
|
|
{
|
|
if (hang_slew_count > 0)
|
|
{
|
|
state = 9;
|
|
time = 0;
|
|
|
|
if ((tidx = scan_idx + hang_slew_count - adv_count - adv_slew_count) >= dline_size)
|
|
tidx -= dline_size;
|
|
|
|
if (tidx < 0)
|
|
tidx += dline_size;
|
|
|
|
Inext = dline[2 * tidx + 0];
|
|
Qnext = dline[2 * tidx + 1];
|
|
}
|
|
else
|
|
{
|
|
state = 0;
|
|
overflow = 0;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case 9:
|
|
{
|
|
scale = 0.5 - hwave[time];
|
|
out[2 * i + 0] = Inext * scale;
|
|
out[2 * i + 1] = Qnext * scale;
|
|
|
|
if (++time >= hang_slew_count)
|
|
{
|
|
state = 0;
|
|
overflow = 0;
|
|
}
|
|
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (++in_idx == dline_size)
|
|
in_idx = 0;
|
|
|
|
if (++scan_idx == dline_size)
|
|
scan_idx = 0;
|
|
|
|
if (++out_idx == dline_size)
|
|
out_idx = 0;
|
|
}
|
|
}
|
|
else if (in != out)
|
|
{
|
|
std::copy(in, in + buffsize * 2, out);
|
|
}
|
|
}
|
|
|
|
void NOB::setBuffers(float* _in, float* _out)
|
|
{
|
|
in = _in;
|
|
out = _out;
|
|
}
|
|
|
|
void NOB::setSize(int size)
|
|
{
|
|
buffsize = size;
|
|
flush();
|
|
}
|
|
|
|
/********************************************************************************************************
|
|
* *
|
|
* Common interface *
|
|
* *
|
|
********************************************************************************************************/
|
|
|
|
void NOB::setRun(int _run)
|
|
{
|
|
run = _run;
|
|
}
|
|
|
|
void NOB::setMode(int _mode)
|
|
{
|
|
mode = _mode;
|
|
}
|
|
|
|
void NOB::setBuffsize(int size)
|
|
{
|
|
buffsize = size;
|
|
}
|
|
|
|
void NOB::setSamplerate(int rate)
|
|
{
|
|
samplerate = (double) rate;
|
|
init();
|
|
}
|
|
|
|
void NOB::setTau(double tau)
|
|
{
|
|
advslewtime = tau;
|
|
hangslewtime = tau;
|
|
init();
|
|
}
|
|
|
|
void NOB::setHangtime(double _time)
|
|
{
|
|
hangtime = _time;
|
|
init();
|
|
}
|
|
|
|
void NOB::setAdvtime(double _time)
|
|
{
|
|
advtime = _time;
|
|
init();
|
|
}
|
|
|
|
void NOB::setBacktau(double tau)
|
|
{
|
|
backtau = tau;
|
|
init();
|
|
}
|
|
|
|
void NOB::setThreshold(double thresh)
|
|
{
|
|
threshold = thresh;
|
|
}
|
|
|
|
} // namespace
|