#include <common.h>
+////////////////////////////////////////////////////////////////////////////
+// for commands affecting RX, which RX is Listening
+
+#define RL (uni.multirx.lis)
+
////////////////////////////////////////////////////////////////////////////
PRIVATE REAL
if (fabs(low_frequency) >= 0.5 * uni.samplerate) return -1;
if (fabs(high_frequency) >= 0.5 * uni.samplerate) return -2;
if ((low_frequency + 10) >= high_frequency) return -3;
- delFIR_COMPLEX(rx.filt.coef);
+ delFIR_COMPLEX(rx[RL].filt.coef);
- rx.filt.coef = newFIR_Bandpass_COMPLEX(low_frequency,
- high_frequency,
- uni.samplerate,
- ncoef);
+ rx[RL].filt.coef = newFIR_Bandpass_COMPLEX(low_frequency,
+ high_frequency,
+ uni.samplerate,
+ ncoef);
zcvec = newvec_COMPLEX(fftlen, "filter z vec in setFilter");
ptmp = fftw_create_plan(fftlen, FFTW_FORWARD, uni.wisdom.bits);
#ifdef LHS
- for (i = 0; i < ncoef; i++) zcvec[i] = rx.filt.coef->coef[i];
+ for (i = 0; i < ncoef; i++)
+ zcvec[i] = rx[RL].filt.coef->coef[i];
#else
- for (i = 0; i < ncoef; i++) zcvec[fftlen - ncoef + i] = rx.filt.coef->coef[i];
+ for (i = 0; i < ncoef; i++)
+ zcvec[fftlen - ncoef + i] = rx[RL].filt.coef->coef[i];
#endif
- fftw_one(ptmp, (fftw_complex *) zcvec, (fftw_complex *) rx.filt.ovsv->zfvec);
+ fftw_one(ptmp,
+ (fftw_complex *) zcvec,
+ (fftw_complex *) rx[RL].filt.ovsv->zfvec);
fftw_destroy_plan(ptmp);
delvec_COMPLEX(zcvec);
- normalize_vec_COMPLEX(rx.filt.ovsv->zfvec,
- rx.filt.ovsv->fftlen);
- memcpy((char *) rx.filt.save,
- (char *) rx.filt.ovsv->zfvec,
- rx.filt.ovsv->fftlen * sizeof(COMPLEX));
+ normalize_vec_COMPLEX(rx[RL].filt.ovsv->zfvec,
+ rx[RL].filt.ovsv->fftlen);
+ memcpy((char *) rx[RL].filt.save,
+ (char *) rx[RL].filt.ovsv->zfvec,
+ rx[RL].filt.ovsv->fftlen * sizeof(COMPLEX));
return 0;
}
zcvec = newvec_COMPLEX(fftlen, "filter z vec in setFilter");
ptmp = fftw_create_plan(fftlen, FFTW_FORWARD, uni.wisdom.bits);
#ifdef LHS
- for (i = 0; i < ncoef; i++) zcvec[i] = tx.filt.coef->coef[i];
+ for (i = 0; i < ncoef; i++)
+ zcvec[i] = tx.filt.coef->coef[i];
#else
- for (i = 0; i < ncoef; i++) zcvec[fftlen - ncoef + i] = tx.filt.coef->coef[i];
+ for (i = 0; i < ncoef; i++)
+ zcvec[fftlen - ncoef + i] = tx.filt.coef->coef[i];
#endif
- fftw_one(ptmp, (fftw_complex *) zcvec, (fftw_complex *) tx.filt.ovsv->zfvec);
+ fftw_one(ptmp,
+ (fftw_complex *) zcvec,
+ (fftw_complex *) tx.filt.ovsv->zfvec);
fftw_destroy_plan(ptmp);
delvec_COMPLEX(zcvec);
normalize_vec_COMPLEX(tx.filt.ovsv->zfvec,
switch (trx) {
case TX: tx.mode = mode; break;
case RX:
- default: rx.mode = mode; break;
+ default: rx[RL].mode = mode; break;
}
} else
- tx.mode = rx.mode = uni.mode.sdr = mode;
- if (rx.mode == AM) rx.am.gen->mode = AMdet;
- if (rx.mode == SAM) rx.am.gen->mode = SAMdet;
+ tx.mode = rx[RL].mode = uni.mode.sdr = mode;
+ if (rx[RL].mode == AM) rx[RL].am.gen->mode = AMdet;
+ if (rx[RL].mode == SAM) rx[RL].am.gen->mode = SAMdet;
return 0;
}
switch (trx) {
case TX: tx.osc.gen->Frequency = newfreq; break;
case RX:
- default: rx.osc.gen->Frequency = newfreq; break;
+ default: rx[RL].osc.gen->Frequency = newfreq; break;
}
} else
- tx.osc.gen->Frequency = rx.osc.gen->Frequency = newfreq;
+ tx.osc.gen->Frequency = rx[RL].osc.gen->Frequency = newfreq;
return 0;
}
PRIVATE int
setNR(int n, char **p) {
- rx.anr.flag = atoi(p[0]);
+ rx[RL].anr.flag = atoi(p[0]);
return 0;
}
PRIVATE int
setANF(int n, char **p) {
- rx.anf.flag = atoi(p[0]);
+ rx[RL].anf.flag = atoi(p[0]);
return 0;
}
PRIVATE int
setNB(int n, char **p) {
- rx.nb.flag = atoi(p[0]);
+ rx[RL].nb.flag = atoi(p[0]);
return 0;
}
PRIVATE int
setNBvals(int n, char **p) {
- REAL threshold = atof(p[0]);
- rx.nb.gen->threshold = rx.nb.thresh = threshold;
+ REAL threshold = atof(p[0]);
+ rx[RL].nb.gen->threshold = rx[RL].nb.thresh = threshold;
return 0;
}
PRIVATE int
setSDROM(int n, char **p) {
- rx.nb_sdrom.flag = atoi(p[0]);
+ rx[RL].nb_sdrom.flag = atoi(p[0]);
return 0;
}
PRIVATE int
setSDROMvals(int n, char **p) {
REAL threshold = atof(p[0]);
- rx.nb_sdrom.gen->threshold = rx.nb_sdrom.thresh = threshold;
+ rx[RL].nb_sdrom.gen->threshold = rx[RL].nb_sdrom.thresh = threshold;
return 0;
}
PRIVATE int
setBIN(int n, char **p) {
- rx.bin.flag = atoi(p[0]);
+ rx[RL].bin.flag = atoi(p[0]);
return 0;
}
switch(trx) {
case TX: tx.agc.gen->gain.now = gain; break;
case RX:
- default: rx.agc.gen->gain.now = gain; break;
+ default: rx[RL].agc.gen->gain.now = gain; break;
}
} else
- tx.agc.gen->gain.now = rx.agc.gen->gain.now = gain;
+ tx.agc.gen->gain.now = rx[RL].agc.gen->gain.now = gain;
return 0;
}
int setit = atoi(p[0]);
switch (setit) {
case agcOFF:
- rx.agc.gen->mode = agcOFF;
- rx.agc.flag = TRUE;
+ rx[RL].agc.gen->mode = agcOFF;
+ rx[RL].agc.flag = TRUE;
break;
case agcSLOW:
- rx.agc.gen->mode = agcSLOW;
- rx.agc.gen->hang = 10;
- rx.agc.flag = TRUE;
+ rx[RL].agc.gen->mode = agcSLOW;
+ rx[RL].agc.gen->hang = 10;
+ rx[RL].agc.flag = TRUE;
break;
case agcMED:
- rx.agc.gen->mode = agcMED;
- rx.agc.gen->hang = 6;
- rx.agc.flag = TRUE;
+ rx[RL].agc.gen->mode = agcMED;
+ rx[RL].agc.gen->hang = 6;
+ rx[RL].agc.flag = TRUE;
break;
case agcFAST:
- rx.agc.gen->mode = agcFAST;
- rx.agc.gen->hang = 3;
- rx.agc.flag = TRUE;
+ rx[RL].agc.gen->mode = agcFAST;
+ rx[RL].agc.gen->hang = 3;
+ rx[RL].agc.flag = TRUE;
break;
case agcLONG:
- rx.agc.gen->mode = agcLONG;
- rx.agc.gen->hang = 23;
- rx.agc.flag = TRUE;
+ rx[RL].agc.gen->mode = agcLONG;
+ rx[RL].agc.gen->hang = 23;
+ rx[RL].agc.flag = TRUE;
break;
}
return 0;
PRIVATE int
setRXAGCCompression(int n, char **p) {
REAL rxcompression = atof(p[0]);
- rx.agc.gen->gain.top = pow(10.0 , rxcompression * 0.05);
+ rx[RL].agc.gen->gain.top = pow(10.0 , rxcompression * 0.05);
return 0;
}
PRIVATE int
setRXAGCHang(int n, char **p) {
int hang = atoi(p[0]);
- rx.agc.gen->hang =
+ rx[RL].agc.gen->hang =
max(1,
min(23,
hang * uni.samplerate / (1e3 * uni.buflen)));
PRIVATE int
setRXAGCLimit(int n, char **p) {
REAL limit = atof(p[0]);
- rx.agc.gen->gain.lim = 0.001 * limit;
+ rx[RL].agc.gen->gain.lim = 0.001 * limit;
return 0;
}
REAL g = dB2lin(dB);
COMPLEX *src = tx.filt.save,
*trg = tx.filt.ovsv->zfvec;
- for (i = lox; i < hix; i++) {
+ for (i = lox; i < hix; i++) {
trg[i] = Cscl(src[i], g);
if (i) {
int j = l - i;
// 0 dB1 75 dB2 150 dB3 300 dB4 600 dB5 1200 dB6 2000 dB7 2800 dB8 3600
// approximates W2IHY bandcenters.
// no args, revert to no EQ.
+
PRIVATE int
setTXEQ(int n, char **p) {
if (n < 3) {
int i,
lox = f2x(lof),
hix = f2x(hif),
- l = rx.filt.ovsv->fftlen;
+ l = rx[RL].filt.ovsv->fftlen;
REAL g = dB2lin(dB);
- COMPLEX *src = rx.filt.save,
- *trg = rx.filt.ovsv->zfvec;
+ COMPLEX *src = rx[RL].filt.save,
+ *trg = rx[RL].filt.ovsv->zfvec;
for (i = lox; i < hix; i++) {
trg[i] = Cscl(src[i], g);
if (i) {
setRXEQ(int n, char **p) {
if (n < 3) {
// revert to no EQ
- memcpy((char *) rx.filt.ovsv->zfvec,
- (char *) rx.filt.save,
- rx.filt.ovsv->fftlen * sizeof(COMPLEX));
+ memcpy((char *) rx[RL].filt.ovsv->zfvec,
+ (char *) rx[RL].filt.save,
+ rx[RL].filt.ovsv->fftlen * sizeof(COMPLEX));
return 0;
} else {
int i;
delay = atoi(p[1]);
REAL gain = atof(p[2]),
leak = atof(p[3]);
- rx.anf.gen->adaptive_filter_size = taps;
- rx.anf.gen->delay = delay;
- rx.anf.gen->adaptation_rate = gain;
- rx.anf.gen->leakage = leak;
+ rx[RL].anf.gen->adaptive_filter_size = taps;
+ rx[RL].anf.gen->delay = delay;
+ rx[RL].anf.gen->adaptation_rate = gain;
+ rx[RL].anf.gen->leakage = leak;
return 0;
}
delay = atoi(p[1]);
REAL gain = atof(p[2]),
leak = atof(p[3]);
- rx.anr.gen->adaptive_filter_size = taps;
- rx.anr.gen->delay = delay;
- rx.anr.gen->adaptation_rate = gain;
- rx.anr.gen->leakage = leak;
+ rx[RL].anr.gen->adaptive_filter_size = taps;
+ rx[RL].anr.gen->delay = delay;
+ rx[RL].anr.gen->adaptation_rate = gain;
+ rx[RL].anr.gen->leakage = leak;
return 0;
}
setcorrectIQ(int n, char **p) {
int phaseadjustment = atoi(p[0]),
gainadjustment = atoi(p[1]);
- rx.iqfix->phase = 0.001 * (REAL) phaseadjustment;
- rx.iqfix->gain = 1.0+ 0.001 * (REAL) gainadjustment;
+ rx[RL].iqfix->phase = 0.001 * (REAL) phaseadjustment;
+ rx[RL].iqfix->gain = 1.0+ 0.001 * (REAL) gainadjustment;
return 0;
}
PRIVATE int
setcorrectIQphase(int n, char **p) {
int phaseadjustment = atoi(p[0]);
- rx.iqfix->phase = 0.001 * (REAL) phaseadjustment;
+ rx[RL].iqfix->phase = 0.001 * (REAL) phaseadjustment;
return 0;
}
PRIVATE int
setcorrectIQgain(int n, char **p) {
int gainadjustment = atoi(p[0]);
- rx.iqfix->gain = 1.0 + 0.001 * (REAL) gainadjustment;
+ rx[RL].iqfix->gain = 1.0 + 0.001 * (REAL) gainadjustment;
return 0;
}
PRIVATE int
setSquelch(int n, char **p) {
- rx.squelch.thresh = -atof(p[0]);
+ rx[RL].squelch.thresh = -atof(p[0]);
return 0;
}
PRIVATE int
setSquelchSt(int n, char **p) {
- rx.squelch.flag = atoi(p[0]);
+ rx[RL].squelch.flag = atoi(p[0]);
return 0;
}
freq = atof(p[1]),
rise = atof(p[2]),
fall = atof(p[3]);
- setSpotToneGenVals(rx.spot.gen, gain, freq, rise, fall);
+ setSpotToneGenVals(rx[RL].spot.gen, gain, freq, rise, fall);
return 0;
}
PRIVATE int
setSpotTone(int n, char **p) {
if (atoi(p[0])) {
- SpotToneOn(rx.spot.gen);
- rx.spot.flag = TRUE;
+ SpotToneOn(rx[RL].spot.gen);
+ rx[RL].spot.flag = TRUE;
} else
- SpotToneOff(rx.spot.gen);
+ SpotToneOff(rx[RL].spot.gen);
return 0;
}
PRIVATE int
setRXPreScl(int n, char **p) {
- rx.scl.pre.flag = atoi(p[0]);
+ rx[RL].scl.pre.flag = atoi(p[0]);
return 0;
}
PRIVATE int
setRXPreSclVal(int n, char **p) {
- rx.scl.pre.val = dB2lin(atof(p[0]));
+ rx[RL].scl.pre.val = dB2lin(atof(p[0]));
return 0;
}
PRIVATE int
setRXPostScl(int n, char **p) {
- rx.scl.post.flag = atoi(p[0]);
+ rx[RL].scl.post.flag = atoi(p[0]);
return 0;
}
PRIVATE int
setRXPostSclVal(int n, char **p) {
- rx.scl.post.val = dB2lin(atof(p[0]));
+ rx[RL].scl.post.val = dB2lin(atof(p[0]));
return 0;
}
return 0;
}
+PRIVATE int
+setRXListen(int n, char **p) {
+ int lis = atoi(p[0]);
+ if (lis < 0 || lis >= uni.multirx.nrx)
+ return -1;
+ else {
+ uni.multirx.lis = lis;
+ return 0;
+ }
+}
+
+PRIVATE int
+setRXOn(int n, char **p) {
+ if (n < 1) {
+ if (uni.multirx.act[RL])
+ return -1;
+ else {
+ uni.multirx.act[RL] = TRUE;
+ uni.multirx.nac++;
+ rx[RL].tick = 0;
+ return 0;
+ }
+ } else {
+ int k = atoi(p[0]);
+ if (k < 0 || k >= uni.multirx.nrx)
+ return -1;
+ else {
+ if (uni.multirx.act[k])
+ return -1;
+ else {
+ uni.multirx.act[k] = TRUE;
+ uni.multirx.nac++;
+ rx[k].tick = 0;
+ return 0;
+ }
+ }
+ }
+}
+
+PRIVATE int
+setRXOff(int n, char **p) {
+ if (n < 1) {
+ if (!uni.multirx.act[RL])
+ return -1;
+ else {
+ uni.multirx.act[RL] = FALSE;
+ --uni.multirx.nac;
+ return 0;
+ }
+ } else {
+ int k = atoi(p[0]);
+ if (k < 0 || k >= uni.multirx.nrx)
+ return -1;
+ else {
+ if (!uni.multirx.act[k])
+ return -1;
+ else {
+ uni.multirx.act[k] = FALSE;
+ --uni.multirx.nac;
+ return 0;
+ }
+ }
+ }
+}
+
+PRIVATE int
+setRXPan(int n, char **p) {
+ REAL pos, theta;
+ if (n < 1) {
+ pos = 0.5;
+ theta = (1.0 - pos) * M_PI / 2.0;
+ rx[RL].azim = Cmplx(cos(theta), sin(theta));
+ return 0;
+ } else {
+ if ((pos = atof(p[0])) < 0.0 || pos > 1.0)
+ return -1;
+ theta = (1.0 - pos) * M_PI / 2.0;
+ rx[RL].azim = Cmplx(cos(theta), sin(theta));
+ return 0;
+ }
+}
+
//========================================================================
#include <thunk.h>
{"setfixedAGC", setfixedAGC},
{"setMonDump", setMonDump},
{"setRingBufferReset", setRingBufferReset},
+ {"setRXListen", setRXListen},
+ {"setRXOn", setRXOn},
+ {"setRXOff", setRXOff},
+ {"setRXPan", setRXPan},
{ 0, 0 }
};
projects / dttsp.git / blobdiff