You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
656 lines
21 KiB
656 lines
21 KiB
/* 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 = new double[dline_size * 2]; |
|
imp = new int[dline_size]; |
|
awave = new double[(int)(MAX_ADV_SLEW_TIME * MAX_SAMPLERATE + 1)]; |
|
hwave = new double[(int)(MAX_HANG_SLEW_TIME * MAX_SAMPLERATE + 1)]; |
|
|
|
filterlen = 10; |
|
bfbuff = new double[filterlen * 2]; |
|
ffbuff = new double[filterlen * 2]; |
|
fcoefs = new double[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(); |
|
} |
|
|
|
NOB::~NOB() |
|
{ |
|
delete[] fcoefs; |
|
delete[] ffbuff; |
|
delete[] bfbuff; |
|
delete[] hwave; |
|
delete[] awave; |
|
delete[] imp; |
|
delete[] dline; |
|
} |
|
|
|
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, dline + dline_size * 2, 0); |
|
std::fill(imp, imp + dline_size, 0); |
|
std::fill(bfbuff, bfbuff + filterlen * 2, 0); |
|
std::fill(ffbuff, ffbuff + filterlen * 2, 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
|
|
|