Asterisk
/
asterisk
mirror of https://github.com/asterisk/asterisk
1
0
Fork 0
Code Issues Releases Wiki Activity
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.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'bbbef73276'
${ noResults }
asterisk/channels/xpmr/xpmr.c

2257 lines
50 KiB
Raw Blame History

/*
* xpmr.c - Xelatec Private Mobile Radio Processes
*
* All Rights Reserved. Copyright (C)2007, Xelatec, LLC
*
* 20070808 1235 Steven Henke, W9SH, sph@xelatec.com
*
* See http://www.asterisk.org for more information about
* the Asterisk project. Please do not directly contact
* any of the maintainers of this project for assistance;
* the project provides a web site, mailing lists and IRC
* channels for your use.
*
* This program is free software, distributed under the terms of
* the GNU General Public License Version 2. See the LICENSE file
* at the top of the source tree.
*/
/*! \file
*
* \brief Private Land Mobile Radio Channel Voice and Signaling Processor
*
* \author Steven Henke, W9SH <sph@xelatec.com> Xelatec, LLC
*/
/*
FYI = For Your Information
PMR = Private Mobile Radio
RX = Receive
TX = Transmit
CTCSS = Continuous Tone Coded Squelch System
TONE = Same as above.
LSD = Low Speed Data, subaudible signaling. May be tones or codes.
VOX = Voice Operated Transmit
DSP = Digital Signal Processing
LPF = Low Pass Filter
FIR = Finite Impulse Response (Filter)
IIR = Infinite Impulse Response (Filter)
*/
#include <stdio.h>
#include <ctype.h>
#include <math.h>
#include <string.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <sys/time.h>
#include <stdlib.h>
#include <errno.h>
#include "xpmr.h"
#include "xpmr_coef.h"
#include "sinetabx.h"
static i16 pmrChanIndex=0; // count of created pmr instances
/*
Convert a Frequency in Hz to a zero based CTCSS Table index
*/
i16 CtcssFreqIndex(float freq)
{
i16 i,hit=-1;
for(i=0;i<CTCSS_NUM_CODES;i++){
if(freq==freq_ctcss[i])hit=i;
}
return hit;
}
/*
pmr_rx_frontend
Takes a block of data and low pass filters it.
Determines the amplitude of high frequency noise for carrier detect.
Decimates input data to change the rate.
*/
i16 pmr_rx_frontend(t_pmr_sps *mySps)
{
#define DCgainBpfNoise 65536
i16 samples,iOutput, *input, *output, *noutput;
i16 *x, *coef, *coef2;
i32 i, naccum, outputGain, calcAdjust;
i64 y;
i16 nx, hyst, setpt, compOut;
i16 amax, amin, apeak, discounteru, discounterl, discfactor;
i16 decimator, decimate, doNoise;
TRACEX(("pmr_rx_frontend()\n"));
if(!mySps->enabled)return(1);
decimator = mySps->decimator;
decimate = mySps->decimate;
input = mySps->source;
output = mySps->sink;
noutput = mySps->parentChan->pRxNoise;
nx = mySps->nx;
coef = mySps->coef;
coef2 = mySps->coef2;
calcAdjust = mySps->calcAdjust;
outputGain = mySps->outputGain;
amax=mySps->amax;
amin=mySps->amin;
apeak=mySps->apeak;
discounteru=mySps->discounteru;
discounterl=mySps->discounterl;
discfactor=mySps->discfactor;
setpt=mySps->setpt;
hyst=mySps->hyst;
compOut=mySps->compOut;
samples=mySps->nSamples*decimate;
x=mySps->x;
iOutput=0;
if(mySps->parentChan->rxCdType!=CD_XPMR_VOX)doNoise=1;
else doNoise=0;
for(i=0;i<samples;i++)
{
i16 n;
//shift the old samples
for(n=nx-1; n>0; n--)
x[n] = x[n-1];
x[0] = input[i*2];
--decimator;
if(decimator<=0)
{
decimator=decimate;
y=0;
for(n=0; n<nx; n++)
y += coef[n] * x[n];
y=((y/calcAdjust)*outputGain)/M_Q8;
if(y>32767)y=32767;
else if(y<-32767)y=-32767;
output[iOutput]=y; // Rx Baseband decimated
noutput[iOutput++] = apeak; // Rx Noise
}
if(doNoise)
{
// calculate noise output
naccum=0;
for(n=0; n<nx; n++)
naccum += coef_fir_bpf_noise_1[n] * x[n];
naccum /= DCgainBpfNoise;
if(naccum>amax)
{
amax=naccum;
discounteru=discfactor;
}
else if(--discounteru<=0)
{
discounteru=discfactor;
amax=(i32)((amax*32700)/32768);
}
if(naccum<amin)
{
amin=naccum;
discounterl=discfactor;
}
else if(--discounterl<=0)
{
discounterl=discfactor;
amin=(i32)((amin*32700)/32768);
}
apeak=(amax-amin)/2;
} // if doNoise
}
if(doNoise)
{
((t_pmr_chan *)(mySps->parentChan))->rxRssi=apeak;
if(apeak>setpt || (compOut&&(apeak>(setpt-hyst)))) compOut=1;
else compOut=0;
mySps->compOut=compOut;
mySps->amax=amax;
mySps->amin=amin;
mySps->apeak=apeak;
mySps->discounteru=discounteru;
mySps->discounterl=discounterl;
}
return 0;
}
/*
pmr general purpose fir
works on a block of samples
*/
i16 pmr_gp_fir(t_pmr_sps *mySps)
{
i32 nsamples,inputGain,outputGain,calcAdjust;
i16 *input, *output;
i16 *x, *coef;
i32 i, ii;
i16 nx, hyst, setpt, compOut;
i16 amax, amin, apeak=0, discounteru=0, discounterl=0, discfactor;
i16 decimator, decimate, interpolate;
i16 numChanOut, selChanOut, mixOut, monoOut;
TRACEX(("pmr_gp_fir() %i\n",mySps->enabled));
if(!mySps->enabled)return(1);
inputGain = mySps->inputGain;
calcAdjust = mySps->calcAdjust;
outputGain = mySps->outputGain;
input = mySps->source;
output = mySps->sink;
x = mySps->x;
nx = mySps->nx;
coef = mySps->coef;
decimator = mySps->decimator;
decimate = mySps->decimate;
interpolate = mySps->interpolate;
setpt = mySps->setpt;
compOut = mySps->compOut;
inputGain = mySps->inputGain;
outputGain = mySps->outputGain;
numChanOut = mySps->numChanOut;
selChanOut = mySps->selChanOut;
mixOut = mySps->mixOut;
monoOut = mySps->monoOut;
amax=mySps->amax;
amin=mySps->amin;
discfactor=mySps->discfactor;
hyst=mySps->hyst;
setpt=mySps->setpt;
nsamples=mySps->nSamples;
if(mySps->option==3)
{
mySps->option=0;
mySps->enabled=0;
for(i=0;i<nsamples;i++)
{
if(monoOut)
output[(i*2)]=output[(i*2)+1]=0;
else
output[(i*numChanOut)+selChanOut]=0;
}
return 0;
}
ii=0;
for(i=0;i<nsamples;i++)
{
int ix;
int64_t y=0;
if(decimate<0)
{
decimator=decimate;
}
for(ix=0;ix<interpolate;ix++)
{
i16 n;
y=0;
for(n=nx-1; n>0; n--)
x[n] = x[n-1];
x[0] = (input[i]*inputGain)/M_Q8;
#if 0
--decimator;
if(decimator<=0)
{
decimator=decimate;
for(n=0; n<nx; n++)
y += coef[n] * x[n];
y /= (outputGain*3);
output[ii++]=y;
}
#else
for(n=0; n<nx; n++)
y += coef[n] * x[n];
y=((y/calcAdjust)*outputGain)/M_Q8;
if(mixOut){
if(monoOut){
output[(ii*2)]=output[(ii*2)+1]+=y;
}
else{
output[(ii*numChanOut)+selChanOut]+=y;
}
}
else{
if(monoOut){
output[(ii*2)]=output[(ii*2)+1]=y;
}
else{
output[(ii*numChanOut)+selChanOut]=y;
}
}
ii++;
#endif
}
// amplitude detector
if(setpt)
{
i16 accum=y;
if(accum>amax)
{
amax=accum;
discounteru=discfactor;
}
else if(--discounteru<=0)
{
discounteru=discfactor;
amax=(i32)((amax*32700)/32768);
}
if(accum<amin)
{
amin=accum;
discounterl=discfactor;
}
else if(--discounterl<=0)
{
discounterl=discfactor;
amin=(i32)((amin*32700)/32768);
}
apeak = (i32)(amax-amin)/2;
if(apeak>setpt)compOut=1;
else if(compOut&&(apeak<(setpt-hyst)))compOut=0;
}
}
mySps->decimator = decimator;
mySps->amax=amax;
mySps->amin=amin;
mySps->apeak=apeak;
mySps->discounteru=discounteru;
mySps->discounterl=discounterl;
mySps->compOut=compOut;
return 0;
}
/*
general purpose integrator lpf
*/
i16 gp_inte_00(t_pmr_sps *mySps)
{
i16 npoints;
i16 *input, *output;
i32 inputGain, outputGain,calcAdjust;
i32 i;
i32 accum;
i32 state00;
i16 coeff00, coeff01;
TRACEX(("gp_inte_00() %i\n",mySps->enabled));
if(!mySps->enabled)return(1);
input = mySps->source;
output = mySps->sink;
npoints=mySps->nSamples;
inputGain=mySps->inputGain;
outputGain=mySps->outputGain;
calcAdjust=mySps->calcAdjust;
coeff00=((i16*)mySps->coef)[0];
coeff01=((i16*)mySps->coef)[1];
state00=((i32*)mySps->x)[0];
// note fixed gain of 2 to compensate for attenuation
// in passband
for(i=0;i<npoints;i++)
{
accum=input[i];
state00 = accum + (state00*coeff01)/M_Q15;
accum = (state00*coeff00)/(M_Q15/4);
output[i]=(accum*outputGain)/M_Q8;
}
((i32*)(mySps->x))[0]=state00;
return 0;
}
/*
general purpose differentiator hpf
*/
i16 gp_diff(t_pmr_sps *mySps)
{
i16 *input, *output;
i16 npoints;
i32 inputGain, outputGain, calcAdjust;
i32 i;
i32 temp0,temp1;
i16 x0;
i32 y0;
i16 a0,a1;
i16 b0;
i16 *coef;
i16 *x;
input = mySps->source;
output = mySps->sink;
npoints=mySps->nSamples;
inputGain=mySps->inputGain;
outputGain=mySps->outputGain;
calcAdjust=mySps->calcAdjust;
coef=(i16*)(mySps->coef);
x=(i16*)(mySps->x);
a0=coef[0];
a1=coef[1];
b0=coef[2];
x0=x[0];
TRACEX(("gp_diff()\n"));
for (i=0;i<npoints;i++)
{
temp0 = x0 * a1;
x0 = input[i];
temp1 = input[i] * a0;
y0 = (temp0 + temp1)/calcAdjust;
output[i]=(y0*outputGain)/M_Q8;
}
x[0]=x0;
return 0;
}
/* ----------------------------------------------------------------------
CenterSlicer
*/
i16 CenterSlicer(t_pmr_sps *mySps)
{
i16 npoints,lhit,uhit;
i16 *input, *output, *buff;
i32 inputGain, outputGain, inputGainB;
i32 i;
i32 accum;
i32 amax; // buffer amplitude maximum
i32 amin; // buffer amplitude minimum
i32 apeak; // buffer amplitude peak
i32 center;
i32 setpt; // amplitude set point for peak tracking
i32 discounteru; // amplitude detector integrator discharge counter upper
i32 discounterl; // amplitude detector integrator discharge counter lower
i32 discfactor; // amplitude detector integrator discharge factor
TRACEX(("CenterSlicer() %i\n",mySps->enabled));
input = mySps->source;
output = mySps->sink;
buff = mySps->buff;
npoints=mySps->nSamples;
inputGain=mySps->inputGain;
outputGain=mySps->outputGain;
inputGainB=mySps->inputGainB;
amax=mySps->amax;
amin=mySps->amin;
setpt=mySps->setpt;
apeak=mySps->apeak;
discounteru=mySps->discounteru;
discounterl=mySps->discounterl;
discfactor=mySps->discfactor;
npoints=mySps->nSamples;
for(i=0;i<npoints;i++)
{
accum=input[i];
lhit=uhit=0;
if(accum>amax)
{
amax=accum;
uhit=1;
if(amin<(amax-setpt))
{
amin=(amax-setpt);
lhit=1;
}
}
else if(accum<amin)
{
amin=accum;
lhit=1;
if(amax>(amin+setpt))
{
amax=(amin+setpt);
uhit=1;
}
}
if(--discounteru<=0 && amax>0)
{
amax--;
uhit=1;
}
if(--discounterl<=0 && amin<0)
{
amin++;
lhit=1;
}
if(uhit)discounteru=discfactor;
if(lhit)discounterl=discfactor;
apeak = (amax-amin)/2;
center = (amax+amin)/2;
accum = accum - center;
output[i]=accum;
// do limiter function
if(accum>inputGainB)accum=inputGainB;
else if(accum<-inputGainB)accum=-inputGainB;
buff[i]=accum;
#if XPMR_DEBUG0 == 1
#if 0
mySps->debugBuff0[i]=center;
#endif
#if 0
if(mySps->parentChan->frameCountRx&0x01) mySps->parentChan->prxDebug1[i]=amax;
else mySps->parentChan->prxDebug1[i]=amin;
#endif
#endif
}
mySps->amax=amax;
mySps->amin=amin;
mySps->apeak=apeak;
mySps->discounteru=discounteru;
mySps->discounterl=discounterl;
return 0;
}
/* ----------------------------------------------------------------------
MeasureBlock
determine peak amplitude
*/
i16 MeasureBlock(t_pmr_sps *mySps)
{
i16 npoints;
i16 *input, *output;
i32 inputGain, outputGain;
i32 i;
i32 accum;
i16 amax; // buffer amplitude maximum
i16 amin; // buffer amplitude minimum
i16 apeak=0; // buffer amplitude peak (peak to peak)/2
i16 setpt; // amplitude set point for amplitude comparator
i32 discounteru; // amplitude detector integrator discharge counter upper
i32 discounterl; // amplitude detector integrator discharge counter lower
i32 discfactor; // amplitude detector integrator discharge factor
TRACEX(("MeasureBlock() %i\n",mySps->enabled));
if(!mySps->enabled)return 1;
if(mySps->option==3)
{
mySps->amax = mySps->amin = mySps->apeak = \
mySps->discounteru = mySps->discounterl = \
mySps->enabled = 0;
return 1;
}
input = mySps->source;
output = mySps->sink;
npoints=mySps->nSamples;
inputGain=mySps->inputGain;
outputGain=mySps->outputGain;
amax=mySps->amax;
amin=mySps->amin;
setpt=mySps->setpt;
discounteru=mySps->discounteru;
discounterl=mySps->discounterl;
discfactor=mySps->discfactor;
npoints=mySps->nSamples;
for(i=0;i<npoints;i++)
{
accum=input[i];
if(accum>amax)
{
amax=accum;
discounteru=discfactor;
}
else if(--discounteru<=0)
{
discounteru=discfactor;
amax=(i32)((amax*32700)/32768);
}
if(accum<amin)
{
amin=accum;
discounterl=discfactor;
}
else if(--discounterl<=0)
{
discounterl=discfactor;
amin=(i32)((amin*32700)/32768);
}
apeak = (i32)(amax-amin)/2;
if(output)output[i]=apeak;
}
mySps->amax=amax;
mySps->amin=amin;
mySps->apeak=apeak;
mySps->discounteru=discounteru;
mySps->discounterl=discounterl;
if(apeak>=setpt) mySps->compOut=1;
else mySps->compOut=0;
//TRACEX((" -MeasureBlock()=%i\n",mySps->apeak));
return 0;
}
/*
SoftLimiter
*/
i16 SoftLimiter(t_pmr_sps *mySps)
{
i16 npoints;
//i16 samples, lhit,uhit;
i16 *input, *output;
i32 inputGain, outputGain;
i32 i;
i32 accum;
i32 tmp;
i32 amax; // buffer amplitude maximum
i32 amin; // buffer amplitude minimum
//i32 apeak; // buffer amplitude peak
i32 setpt; // amplitude set point for amplitude comparator
i16 compOut; // amplitude comparator output
input = mySps->source;
output = mySps->sink;
inputGain=mySps->inputGain;
outputGain=mySps->outputGain;
npoints=mySps->nSamples;
setpt=mySps->setpt;
amax=(setpt*124)/128;
amin=-amax;
TRACEX(("SoftLimiter() %i %i %i) \n",amin, amax,setpt));
for(i=0;i<npoints;i++)
{
accum=input[i];
//accum=input[i]*mySps->inputGain/256;
if(accum>setpt)
{
tmp=((accum-setpt)*4)/128;
accum=setpt+tmp;
if(accum>amax)accum=amax;
compOut=1;
accum=setpt;
}
else if(accum<-setpt)
{
tmp=((accum+setpt)*4)/128;
accum=(-setpt)-tmp;
if(accum<amin)accum=amin;
compOut=1;
accum=-setpt;
}
output[i]=(accum*outputGain)/M_Q8;
}
return 0;
}
/*
SigGen() - sine, square function generator
sps overloaded values
discfactor = phase factor
discfactoru = phase index
if source is not NULL then mix it in!
sign table and output gain are in Q15 format (32767=.999)
*/
i16 SigGen(t_pmr_sps *mySps)
{
#define PH_FRACT_FACT 128
i32 ph;
i16 i,outputgain,waveform,numChanOut,selChanOut;
i32 accum;
TRACEX(("SigGen(%i) \n",mySps->option));
if(!mySps->freq ||!mySps->enabled)return 0;
outputgain=mySps->outputGain;
waveform=0;
numChanOut=mySps->numChanOut;
selChanOut=mySps->selChanOut;
if(mySps->option==1)
{
mySps->option=0;
mySps->state=1;
mySps->discfactor=
(SAMPLES_PER_SINE*mySps->freq*PH_FRACT_FACT)/mySps->sampleRate/10;
TRACEX((" SigGen() discfactor = %i\n",mySps->discfactor));
if(mySps->discounterl)mySps->state=2;
}
else if(mySps->option==2)
{
i16 shiftfactor=CTCSS_TURN_OFF_SHIFT;
// phase shift request
mySps->option=0;
mySps->state=2;
mySps->discounterl=CTCSS_TURN_OFF_TIME-(2*MS_PER_FRAME); //
mySps->discounteru = \
(mySps->discounteru + (((SAMPLES_PER_SINE*shiftfactor)/360)*PH_FRACT_FACT)) % (SAMPLES_PER_SINE*PH_FRACT_FACT);
//printf("shiftfactor = %i\n",shiftfactor);
//shiftfactor+=10;
}
else if(mySps->option==3)
{
// stop it and clear the output buffer
mySps->option=0;
mySps->state=0;
mySps->enabled=0;
for(i=0;i<mySps->nSamples;i++)
mySps->sink[(i*numChanOut)+selChanOut]=0;
return(0);
}
else if(mySps->state==2)
{
// doing turn off
mySps->discounterl-=MS_PER_FRAME;
if(mySps->discounterl<=0)
{
mySps->option=3;
mySps->state=2;
}
}
else if(mySps->state==0)
{
return(0);
}
ph=mySps->discounteru;
for(i=0;i<mySps->nSamples;i++)
{
if(!waveform)
{
// sine
//tmp=(sinetablex[ph/PH_FRACT_FACT]*amplitude)/M_Q16;
accum=sinetablex[ph/PH_FRACT_FACT];
accum=(accum*outputgain)/M_Q8;
}
else
{
// square
if(ph>SAMPLES_PER_SINE/2)
accum=outputgain/M_Q8;
else
accum=-outputgain/M_Q8;
}
if(mySps->source)accum+=mySps->source[i];
mySps->sink[(i*numChanOut)+selChanOut]=accum;
ph=(ph+mySps->discfactor)%(SAMPLES_PER_SINE*PH_FRACT_FACT);
}
mySps->discounteru=ph;
return 0;
}
/*
adder/mixer
takes existing buffer and adds source buffer to destination buffer
sink buffer = (sink buffer * gain) + source buffer
*/
i16 pmrMixer(t_pmr_sps *mySps)
{
i32 accum;
i16 i, *input, *inputB, *output;
i16 inputGain, inputGainB; // apply to input data in Q7.8 format
i16 outputGain; // apply to output data in Q7.8 format
i16 discounteru,discounterl,amax,amin,setpt,discfactor;
i16 npoints,uhit,lhit,apeak,measPeak;
TRACEX(("pmrMixer()\n"));
input = mySps->source;
inputB = mySps->sourceB;
output = mySps->sink;
inputGain=mySps->inputGain;
inputGainB=mySps->inputGainB;
outputGain=mySps->outputGain;
amax=mySps->amax;
amin=mySps->amin;
setpt=mySps->setpt;
discounteru=mySps->discounteru;
discounterl=mySps->discounteru;
discfactor=mySps->discfactor;
npoints=mySps->nSamples;
measPeak=mySps->measPeak;
for(i=0;i<npoints;i++)
{
accum = ((input[i]*inputGain)/M_Q8) +
((inputB[i]*inputGainB)/M_Q8);
accum=(accum*outputGain)/M_Q8;
output[i]=accum;
if(measPeak){
lhit=uhit=0;
if(accum>amax){
amax=accum;
uhit=1;
if(amin<(amax-setpt)){
amin=(amax-setpt);
lhit=1;
}
}
else if(accum<amin){
amin=accum;
lhit=1;
if(amax>(amin+setpt)){
amax=(amin+setpt);
uhit=1;
}
}
if(--discounteru<=0 && amax>0){
amax--;
uhit=1;
}
if(--discounterl<=0 && amin<0){
amin++;
lhit=1;
}
if(uhit)discounteru=discfactor;
if(lhit)discounterl=discfactor;
}
}
if(measPeak){
apeak = (amax-amin)/2;
mySps->apeak=apeak;
mySps->amax=amax;
mySps->amin=amin;
mySps->discounteru=discounteru;
mySps->discounterl=discounterl;
}
return 0;
}
/*
DelayLine
*/
i16 DelayLine(t_pmr_sps *mySps)
{
i16 *input, *output, *buff;
i16 i, npoints,buffsize,inindex,outindex;
TRACEX((" DelayLine() %i\n",mySps->enabled));
input = mySps->source;
output = mySps->sink;
buff = (i16*)(mySps->buff);
buffsize = mySps->buffSize;
npoints = mySps->nSamples;
outindex = mySps->buffOutIndex;
inindex = outindex + mySps->buffLead;
for(i=0;i<npoints;i++)
{
inindex %= buffsize;
outindex %= buffsize;
buff[inindex]=input[i];
output[i]=buff[outindex];
inindex++;
outindex++;
}
mySps->buffOutIndex=outindex;
return 0;
}
/*
Continuous Tone Coded Squelch (CTCSS) Detector
*/
i16 ctcss_detect(t_pmr_chan *pmrChan)
{
i16 i,points2do, points=0, *pInput, hit, thit,relax;
i16 tnum, tmp, indexWas=0, indexNow, gain, peakwas=0, diffpeak;
i16 difftrig;
i16 lasttv0=0, lasttv1=0, lasttv2=0, tv0, tv1, tv2, indexDebug;
TRACEX(("ctcss_detect(%p) %i %i %i %i\n",pmrChan,
pmrChan->rxCtcss->enabled,
pmrChan->rxCtcssIndex,
pmrChan->rxCtcss->testIndex,
pmrChan->rxCtcss->decode));
if(!pmrChan->rxCtcss->enabled)return(1);
relax = pmrChan->rxCtcss->relax;
pInput = pmrChan->rxCtcss->input;
gain = pmrChan->rxCtcss->gain;
if(relax) difftrig=(-0.1*M_Q15);
else difftrig=(-0.05*M_Q15);
thit=hit=-1;
//TRACEX((" ctcss_detect() %i %i %i %i\n", CTCSS_NUM_CODES,0,0,0));
for(tnum=0;tnum<CTCSS_NUM_CODES;tnum++)
{
i32 accum, peak;
t_tdet *ptdet;
i16 fudgeFactor;
i16 binFactor;
//TRACEX((" ctcss_detect() tnum=%i %i\n",tnum,pmrChan->rxCtcssMap[tnum]));
if( (pmrChan->rxCtcssMap[tnum] < 0) ||
(pmrChan->rxCtcss->decode>=0 && (tnum!= pmrChan->rxCtcss->decode)) ||
(!pmrChan->rxCtcss->multiFreq && (tnum!= pmrChan->rxCtcssIndex))
)
continue;
//TRACEX((" ctcss_detect() tnum=%i\n",tnum));
ptdet=&(pmrChan->rxCtcss->tdet[tnum]);
indexDebug=0;
points=points2do=pmrChan->nSamplesRx;
fudgeFactor=ptdet->fudgeFactor;
binFactor=ptdet->binFactor;
while(ptdet->counter < (points2do*CTCSS_SCOUNT_MUL))
{
//TRACEX((" ctcss_detect() - inner loop\n"));
tmp=(ptdet->counter/CTCSS_SCOUNT_MUL)+1;
ptdet->counter-=(tmp*CTCSS_SCOUNT_MUL);
points2do-=tmp;
indexNow=points-points2do;
ptdet->counter += ptdet->counterFactor;
accum = pInput[indexNow-1]; // dude's major bug fix!
peakwas=ptdet->peak;
ptdet->z[ptdet->zIndex]+=
(((accum - ptdet->z[ptdet->zIndex])*binFactor)/M_Q15);
peak = abs(ptdet->z[0]-ptdet->z[2]) + abs(ptdet->z[1]-ptdet->z[3]);
if (ptdet->peak < peak)
ptdet->peak += ( ((peak-ptdet->peak)*binFactor)/M_Q15);
else
ptdet->peak=peak;
{
static const i16 a0=13723;
static const i16 a1=-13723;
i32 temp0,temp1;
i16 x0;
//differentiate
x0=ptdet->zd;
temp0 = x0 * a1;
ptdet->zd = ptdet->peak;
temp1 = ptdet->peak * a0;
diffpeak = (temp0 + temp1)/1024;
}
if(diffpeak<(-0.03*M_Q15))ptdet->dvd-=4;
else if(ptdet->dvd<0)ptdet->dvd++;
if((ptdet->dvd < -12) && diffpeak > (-0.02*M_Q15))ptdet->dvu+=2;
else if(ptdet->dvu)ptdet->dvu--;
tmp=ptdet->setpt;
if(pmrChan->rxCtcss->decode==tnum)
{
if(relax)tmp=(tmp*55)/100;
else tmp=(tmp*80)/100;
}
if(ptdet->peak > tmp)
{
if(ptdet->decode<(fudgeFactor*32))ptdet->decode++;
}
else if(pmrChan->rxCtcss->decode==tnum)
{
if(ptdet->peak > ptdet->hyst)ptdet->decode--;
else if(relax) ptdet->decode--;
else ptdet->decode-=4;
}
else
{
ptdet->decode=0;
}
if((pmrChan->rxCtcss->decode==tnum) && !relax && (ptdet->dvu > (0.00075*M_Q15)))
{
ptdet->decode=0;
ptdet->z[0]=ptdet->z[1]=ptdet->z[2]=ptdet->z[3]=ptdet->dvu=0;
//printf("ctcss_detect() turnoff code!\n");
}
if(ptdet->decode<0 || !pmrChan->rxCarrierDetect)ptdet->decode=0;
if(ptdet->decode>=fudgeFactor)thit=tnum;
#if XPMR_DEBUG0 == 1
//if(thit>=0 && thit==tnum)
// printf(" ctcss_detect() %i %i %i %i \n",tnum,ptdet->peak,ptdet->setpt,ptdet->hyst);
// tv0=accum;
tv0=ptdet->peak;
tv1=diffpeak;
tv2=ptdet->dvu;
//tv1=ptdet->zi*100;
while(indexDebug<indexNow)
{
if(indexDebug==0)lasttv0=ptdet->pDebug0[points-1];
if(ptdet->pDebug0)ptdet->pDebug0[indexDebug]=lasttv0;
if(indexDebug==0)lasttv1=ptdet->pDebug1[points-1];
if(ptdet->pDebug1)ptdet->pDebug1[indexDebug]=lasttv1;
if(indexDebug==0)lasttv2=ptdet->pDebug2[points-1];
if(ptdet->pDebug2)ptdet->pDebug2[indexDebug]=lasttv2;
indexDebug++;
}
lasttv0=tv0;
lasttv1=tv1;
lasttv2=tv2*100;
#endif
indexWas=indexNow;
ptdet->zIndex=(++ptdet->zIndex)%4;
}
ptdet->counter-=(points2do*CTCSS_SCOUNT_MUL);
#if XPMR_DEBUG0 == 1
for(i=indexWas;i<points;i++)
{
if(ptdet->pDebug0)ptdet->pDebug0[i]=lasttv0;
if(ptdet->pDebug1)ptdet->pDebug1[i]=lasttv1;
if(ptdet->pDebug2)ptdet->pDebug2[i]=lasttv2;
}
#endif
}
//TRACEX((" ctcss_detect() thit %i\n",thit));
if(pmrChan->rxCtcss->BlankingTimer>0)pmrChan->rxCtcss->BlankingTimer-=points;
if(pmrChan->rxCtcss->BlankingTimer<0)pmrChan->rxCtcss->BlankingTimer=0;
if(thit>=0 && pmrChan->rxCtcss->decode<0 && !pmrChan->rxCtcss->BlankingTimer)
{
pmrChan->rxCtcss->decode=thit;
}
else if(thit<0 && pmrChan->rxCtcss->decode>=0)
{
pmrChan->rxCtcss->BlankingTimer=SAMPLE_RATE_NETWORK/5;
pmrChan->rxCtcss->decode=-1;
for(tnum=0;tnum<CTCSS_NUM_CODES;tnum++)
{
t_tdet *ptdet=NULL;
ptdet=&(pmrChan->rxCtcss->tdet[tnum]);
ptdet->decode=0;
ptdet->z[0]=ptdet->z[1]=ptdet->z[2]=ptdet->z[3]=0;
}
}
//TRACEX((" ctcss_detect() thit %i %i\n",thit,pmrChan->rxCtcss->decode));
return(0);
}
/*
TxTestTone
*/
static i16 TxTestTone(t_pmr_chan *pChan, i16 function)
{
if(function==1)
{
pChan->spsSigGen1->enabled=1;
pChan->spsSigGen1->option=1;
pChan->spsTx->source=pChan->spsSigGen1->sink;
}
else
{
pChan->spsSigGen1->option=3;
}
return 0;
}
/*
assumes:
sampling rate is 48KS/s
samples are all 16 bits
samples are filtered and decimated by 1/6th
*/
t_pmr_chan *createPmrChannel(t_pmr_chan *tChan, i16 numSamples)
{
i16 i, *inputTmp;
t_pmr_chan *pChan;
t_pmr_sps *pSps;
t_dec_ctcss *pDecCtcss;
t_tdet *ptdet;
TRACEX(("createPmrChannel(%p,%i)\n",tChan,numSamples));
pChan = (t_pmr_chan *)calloc(sizeof(t_pmr_chan),1);
if(pChan==NULL)
{
printf("createPmrChannel() failed\n");
return(NULL);
}
pChan->nSamplesRx=numSamples;
pChan->nSamplesTx=numSamples;
pChan->index=pmrChanIndex++;
for(i=0;i<CTCSS_NUM_CODES;i++)
{
pChan->rxCtcssMap[i]=-1;
}
pChan->rxCtcssIndex=-1;
if(tChan==NULL)
{
pChan->rxNoiseSquelchEnable=0;
pChan->rxHpfEnable=0;
pChan->rxDeEmpEnable=0;
pChan->rxCenterSlicerEnable=0;
pChan->rxCtcssDecodeEnable=0;
pChan->rxDcsDecodeEnable=0;
pChan->rxCarrierPoint = 17000;
pChan->rxCarrierHyst = 2500;
pChan->rxCtcssFreq=103.5;
pChan->txHpfEnable=0;
pChan->txLimiterEnable=0;
pChan->txPreEmpEnable=0;
pChan->txLpfEnable=1;
pChan->txCtcssFreq=103.5;
pChan->txMixA=TX_OUT_VOICE;
pChan->txMixB=TX_OUT_LSD;
}
else
{
pChan->rxDemod=tChan->rxDemod;
pChan->rxCdType=tChan->rxCdType;
pChan->rxSquelchPoint = tChan->rxSquelchPoint;
pChan->rxCarrierHyst = 3000;
pChan->rxCtcssFreq=tChan->rxCtcssFreq;
for(i=0;i<CTCSS_NUM_CODES;i++)
pChan->rxCtcssMap[i]=tChan->rxCtcssMap[i];
pChan->txMod=tChan->txMod;
pChan->txHpfEnable=1;
pChan->txLpfEnable=1;
pChan->txCtcssFreq=tChan->txCtcssFreq;
pChan->txMixA=tChan->txMixA;
pChan->txMixB=tChan->txMixB;
pChan->radioDuplex=tChan->radioDuplex;
}
TRACEX(("misc settings \n"));
if(pChan->rxCdType==CD_XPMR_NOISE){
pChan->rxNoiseSquelchEnable=1;
}
if(pChan->rxDemod==RX_AUDIO_FLAT){
pChan->rxHpfEnable=1;
pChan->rxDeEmpEnable=1;
}
pChan->rxCarrierPoint=(pChan->rxSquelchPoint*32767)/100;
pChan->rxCarrierHyst = 3000; //pChan->rxCarrierPoint/15;
pChan->rxDcsDecodeEnable=0;
if(pChan->rxCtcssFreq!=0){
pChan->rxHpfEnable=1;
pChan->rxCenterSlicerEnable=1;
pChan->rxCtcssDecodeEnable=1;
pChan->rxCtcssIndex=CtcssFreqIndex(pChan->rxCtcssFreq);
}
if(pChan->txMod){
pChan->txPreEmpEnable=1;
pChan->txLimiterEnable=1;
}
TRACEX(("calloc buffers \n"));
pChan->pRxDemod = calloc(numSamples,2);
pChan->pRxNoise = calloc(numSamples,2);
pChan->pRxBase = calloc(numSamples,2);
pChan->pRxHpf = calloc(numSamples,2);
pChan->pRxLsd = calloc(numSamples,2);
pChan->pRxSpeaker = calloc(numSamples,2);
pChan->pRxCtcss = calloc(numSamples,2);
pChan->pRxDcTrack = calloc(numSamples,2);
pChan->pRxLsdLimit = calloc(numSamples,2);
pChan->pTxBase = calloc(numSamples,2);
pChan->pTxHpf = calloc(numSamples,2);
pChan->pTxPreEmp = calloc(numSamples,2);
pChan->pTxLimiter = calloc(numSamples,2);
pChan->pTxLsd = calloc(numSamples,2);
pChan->pTxLsdLpf = calloc(numSamples,2);
pChan->pTxComposite = calloc(numSamples,2);
pChan->pSigGen0 = calloc(numSamples,2);
pChan->pSigGen1 = calloc(numSamples,2);
pChan->pTxCode = calloc(numSamples,2);
pChan->pTxOut = calloc(numSamples,2*2*6); // output buffer
#if XPMR_DEBUG0 == 1
pChan->pTxPttIn = calloc(numSamples,2);
pChan->pTxPttOut = calloc(numSamples,2);
pChan->prxDebug0 = calloc(numSamples,2);
pChan->prxDebug1 = calloc(numSamples,2);
pChan->prxDebug2 = calloc(numSamples,2);
pChan->prxDebug3 = calloc(numSamples,2);
pChan->ptxDebug0 = calloc(numSamples,2);
pChan->ptxDebug1 = calloc(numSamples,2);
pChan->ptxDebug2 = calloc(numSamples,2);
pChan->ptxDebug3 = calloc(numSamples,2);
pChan->pNull = calloc(numSamples,2);
for(i=0;i<numSamples;i++)pChan->pNull[i]=((i%(numSamples/2))*8000)-4000;
#endif
TRACEX(("create ctcss\n"));
pDecCtcss = (t_dec_ctcss *)calloc(sizeof(t_dec_ctcss),1);
pChan->rxCtcss=pDecCtcss;
pDecCtcss->enabled=1;
pDecCtcss->gain=1*M_Q8;
pDecCtcss->limit=8192;
pDecCtcss->input=pChan->pRxLsdLimit;
pDecCtcss->testIndex=pChan->rxCtcssIndex;
if(!pDecCtcss->testIndex)pDecCtcss->testIndex=1;
pChan->rxCtcssMap[pChan->rxCtcssIndex]=pChan->rxCtcssIndex;
pDecCtcss->decode=-1;
for(i=0;i<CTCSS_NUM_CODES;i++)
{
ptdet=&(pChan->rxCtcss->tdet[i]);
ptdet->state=1;
ptdet->setpt=(M_Q15*0.067); // 0.069
ptdet->hyst =(M_Q15*0.020);
ptdet->counterFactor=coef_ctcss_div[i];
ptdet->binFactor=(M_Q15*0.135); // was 0.140
ptdet->fudgeFactor=8;
}
// General Purpose Function Generator
pSps=pChan->spsSigGen1=createPmrSps();
pSps->parentChan=pChan;
pSps->sink=pChan->pSigGen1;
pSps->numChanOut=1;
pSps->selChanOut=0;
pSps->sigProc=SigGen;
pSps->nSamples=pChan->nSamplesTx;
pSps->sampleRate=SAMPLE_RATE_NETWORK;
pSps->freq=10000; // in increments of 0.1 Hz
pSps->outputGain=(.25*M_Q8);
pSps->option=0;
pSps->interpolate=1;
pSps->decimate=1;
pSps->enabled=0;
// CTCSS ENCODER
pSps = pChan->spsSigGen0 = createPmrSps();
pSps->parentChan=pChan;
pSps->sink=pChan->pTxLsd;
pSps->sigProc=SigGen;
pSps->numChanOut=1;
pSps->selChanOut=0;
pSps->nSamples=pChan->nSamplesTx;
pSps->sampleRate=SAMPLE_RATE_NETWORK;
pSps->freq=pChan->txCtcssFreq*10; // in increments of 0.1 Hz
pSps->outputGain=(0.5*M_Q8);
pSps->option=0;
pSps->interpolate=1;
pSps->decimate=1;
pSps->enabled=0;
// Tx LSD Low Pass Filter
pSps=pChan->spsTxLsdLpf=pSps->nextSps=createPmrSps();
pSps->source=pChan->pTxLsd;
pSps->sink=pChan->pTxLsdLpf;
pSps->sigProc=pmr_gp_fir;
pSps->enabled=0;
pSps->numChanOut=1;
pSps->selChanOut=0;
pSps->nSamples=pChan->nSamplesTx;
pSps->decimator=pSps->decimate=1;
pSps->interpolate=1;
pSps->inputGain=(1*M_Q8);
pSps->outputGain=(1*M_Q8);
if(pChan->txCtcssFreq>203.0)
{
pSps->ncoef=taps_fir_lpf_250_9_66;
pSps->size_coef=2;
pSps->coef=(void*)coef_fir_lpf_250_9_66;
pSps->nx=taps_fir_lpf_250_9_66;
pSps->size_x=2;
pSps->x=(void*)(calloc(pSps->nx,pSps->size_x));
pSps->calcAdjust=gain_fir_lpf_250_9_66;
}
else
{
pSps->ncoef=taps_fir_lpf_215_9_88;
pSps->size_coef=2;
pSps->coef=(void*)coef_fir_lpf_215_9_88;
pSps->nx=taps_fir_lpf_215_9_88;
pSps->size_x=2;
pSps->x=(void*)(calloc(pSps->nx,pSps->size_x));
pSps->calcAdjust=gain_fir_lpf_215_9_88;
}
pSps->inputGain=(1*M_Q8);
pSps->outputGain=(1*M_Q8);
if(pSps==NULL)printf("Error: calloc(), createPmrChannel()\n");
// RX Process
TRACEX(("create rx\n"));
pSps = NULL;
// allocate space for first sps and set pointers
pSps=pChan->spsRx=createPmrSps();
pSps->parentChan=pChan;
pSps->source=NULL; //set when called
pSps->sink=pChan->pRxBase;
pSps->sigProc=pmr_rx_frontend;
pSps->enabled=1;
pSps->decimator=pSps->decimate=6;
pSps->interpolate=pSps->interpolate=1;
pSps->nSamples=pChan->nSamplesRx;
pSps->ncoef=taps_fir_bpf_noise_1;
pSps->size_coef=2;
pSps->coef=(void*)coef_fir_lpf_3K_1;
pSps->coef2=(void*)coef_fir_bpf_noise_1;
pSps->nx=taps_fir_bpf_noise_1;
pSps->size_x=2;
pSps->x=(void*)(calloc(pSps->nx,pSps->size_coef));
pSps->calcAdjust=(gain_fir_lpf_3K_1*256)/0x0100;
pSps->outputGain=(1.0*M_Q8);
pSps->discfactor=2;
pSps->hyst=pChan->rxCarrierHyst;
pSps->setpt=pChan->rxCarrierPoint;
pChan->prxSquelchAdjust=&pSps->setpt;
#if XPMR_DEBUG0 == 1
pSps->debugBuff0=pChan->pRxDemod;
pSps->debugBuff1=pChan->pRxNoise;
pSps->debugBuff2=pChan->prxDebug0;
#endif
// allocate space for next sps and set pointers
// Rx SubAudible Decoder Low Pass Filter
pSps=pSps->nextSps=createPmrSps();
pSps->parentChan=pChan;
pSps->source=pChan->pRxBase;
pSps->sink=pChan->pRxLsd;
pSps->sigProc=pmr_gp_fir;
pSps->enabled=1;
pSps->numChanOut=1;
pSps->selChanOut=0;
pSps->nSamples=pChan->nSamplesRx;
pSps->decimator=pSps->decimate=1;
pSps->interpolate=1;
if(pChan->rxCtcssFreq>203.5)
{
pSps->ncoef=taps_fir_lpf_250_9_66;
pSps->size_coef=2;
pSps->coef=(void*)coef_fir_lpf_250_9_66;
pSps->nx=taps_fir_lpf_250_9_66;
pSps->size_x=2;
pSps->x=(void*)(calloc(pSps->nx,pSps->size_x));
pSps->calcAdjust=gain_fir_lpf_250_9_66;
}
else
{
pSps->ncoef=taps_fir_lpf_215_9_88;
pSps->size_coef=2;
pSps->coef=(void*)coef_fir_lpf_215_9_88;
pSps->nx=taps_fir_lpf_215_9_88;
pSps->size_x=2;
pSps->x=(void*)(calloc(pSps->nx,pSps->size_x));
pSps->calcAdjust=gain_fir_lpf_215_9_88;
}
pSps->inputGain=(1*M_Q8);
pSps->outputGain=(1*M_Q8);
pChan->prxCtcssMeasure=pSps->sink;
pChan->prxCtcssAdjust=&(pSps->outputGain);
// allocate space for next sps and set pointers
// CenterSlicer
if(pChan->rxCenterSlicerEnable)
{
pSps=pSps->nextSps=createPmrSps();
pSps->parentChan=pChan;
pSps->source=pChan->pRxLsd;
pSps->sink=pChan->pRxDcTrack;
pSps->buff=pChan->pRxLsdLimit;
pSps->sigProc=CenterSlicer;
pSps->enabled=1;
pSps->nSamples=pChan->nSamplesRx;
pSps->discfactor=800;
pSps->inputGain=(1*M_Q8);
pSps->outputGain=(1*M_Q8);
pSps->setpt=3000;
pSps->inputGainB=1000; // limiter set point
}
// allocate space for next sps and set pointers
// Rx HPF
pSps=pSps->nextSps=createPmrSps();
pSps->parentChan=pChan;
pChan->spsRxHpf=pSps;
pSps->source=pChan->pRxBase;
pSps->sink=pChan->pRxHpf;
pSps->sigProc=pmr_gp_fir;
pSps->enabled=1;
pSps->numChanOut=1;
pSps->selChanOut=0;
pSps->nSamples=pChan->nSamplesRx;
pSps->decimator=pSps->decimate=1;
pSps->interpolate=1;
pSps->ncoef=taps_fir_hpf_300_9_66;
pSps->size_coef=2;
pSps->coef=(void*)coef_fir_hpf_300_9_66;
pSps->nx=taps_fir_hpf_300_9_66;
pSps->size_x=2;
pSps->x=(void*)(calloc(pSps->nx,pSps->size_x));
if(pSps==NULL)printf("Error: calloc(), createPmrChannel()\n");
pSps->calcAdjust=gain_fir_hpf_300_9_66;
pSps->inputGain=(1*M_Q8);
pSps->outputGain=(1*M_Q8);
pChan->spsRxOut=pSps;
// allocate space for next sps and set pointers
// Rx DeEmp
if(pChan->rxDeEmpEnable){
pSps=pSps->nextSps=createPmrSps();
pSps->parentChan=pChan;
pChan->spsRxDeEmp=pSps;
pSps->source=pChan->pRxHpf;
pSps->sink=pChan->pRxSpeaker;
pChan->spsRxOut=pSps; // OUTPUT STRUCTURE! maw
pSps->sigProc=gp_inte_00;
pSps->enabled=1;
pSps->nSamples=pChan->nSamplesRx;
pSps->ncoef=taps_int_lpf_300_1_2;
pSps->size_coef=2;
pSps->coef=(void*)coef_int_lpf_300_1_2;
pSps->nx=taps_int_lpf_300_1_2;
pSps->size_x=4;
pSps->x=(void*)(calloc(pSps->nx,pSps->size_x));
if(pSps==NULL)printf("Error: calloc(), createPmrChannel()\n");
pSps->calcAdjust=gain_int_lpf_300_1_2/2;
pSps->inputGain=(1.0*M_Q8);
pSps->outputGain=(1.0*M_Q8);
pChan->prxVoiceMeasure=pSps->sink;
pChan->prxVoiceAdjust=&(pSps->outputGain);
}
if(pChan->rxDelayLineEnable)
{
TRACEX(("create delayline\n"));
pSps=pChan->spsDelayLine=pSps->nextSps=createPmrSps();
pSps->sigProc=DelayLine;
pSps->source=pChan->pRxSpeaker;
pSps->sink=pChan->pRxSpeaker;
pSps->enabled=0;
pSps->inputGain=1*M_Q8;
pSps->outputGain=1*M_Q8;
pSps->nSamples=pChan->nSamplesRx;
pSps->buffSize=4096;
pSps->buff=calloc(4096,2); // one second maximum
pSps->buffLead = (SAMPLE_RATE_NETWORK*0.100);
pSps->buffOutIndex=0;
}
if(pChan->rxCdType==CD_XPMR_VOX)
{
TRACEX(("create vox measureblock\n"));
pSps=pChan->spsRxVox=pSps->nextSps=createPmrSps();
pSps->sigProc=MeasureBlock;
pSps->parentChan=pChan;
pSps->source=pChan->pRxBase;
pSps->sink=pChan->prxDebug1;
pSps->inputGain=1*M_Q8;
pSps->outputGain=1*M_Q8;
pSps->nSamples=pChan->nSamplesRx;
pSps->discfactor=3;
pSps->setpt=(0.01*M_Q15);
pSps->hyst=(pSps->setpt/10);
pSps->enabled=1;
}
// tuning measure block
pSps=pChan->spsMeasure=pSps->nextSps=createPmrSps();
pSps->parentChan=pChan;
pSps->source=pChan->spsRx->sink;
pSps->sink=pChan->prxDebug2;
pSps->sigProc=MeasureBlock;
pSps->enabled=0;
pSps->nSamples=pChan->nSamplesRx;
pSps->discfactor=10;
pSps->nextSps=NULL; // last sps in chain RX
// CREATE TRANSMIT CHAIN
TRACEX((" create tx\n"));
inputTmp=NULL;
pSps = NULL;
// allocate space for first sps and set pointers
// Tx HPF SubAudible
if(pChan->txHpfEnable)
{
pSps=createPmrSps();
pChan->spsTx=pSps;
pSps->source=pChan->pTxBase;
pSps->sink=pChan->pTxHpf;
pSps->sigProc=pmr_gp_fir;
pSps->enabled=1;
pSps->numChanOut=1;
pSps->selChanOut=0;
pSps->nSamples=pChan->nSamplesTx;
pSps->decimator=pSps->decimate=1;
pSps->interpolate=1;
pSps->ncoef=taps_fir_hpf_300_9_66;
pSps->size_coef=2;
pSps->coef=(void*)coef_fir_hpf_300_9_66;
pSps->nx=taps_fir_hpf_300_9_66;
pSps->size_x=2;
pSps->x=(void*)(calloc(pSps->nx,pSps->size_x));
if(pSps==NULL)printf("Error: calloc(), createPmrChannel()\n");
pSps->calcAdjust=gain_fir_hpf_300_9_66;
pSps->inputGain=(1*M_Q8);
pSps->outputGain=(1*M_Q8);
inputTmp=pChan->pTxHpf;
}
// Tx PreEmphasis
if(pChan->txPreEmpEnable)
{
if(pSps==NULL) pSps=pChan->spsTx=createPmrSps();
else pSps=pSps->nextSps=createPmrSps();
pSps->parentChan=pChan;
pSps->source=inputTmp;
pSps->sink=pChan->pTxPreEmp;
pSps->sigProc=gp_diff;
pSps->enabled=1;
pSps->nSamples=pChan->nSamplesTx;
pSps->ncoef=taps_int_hpf_4000_1_2;
pSps->size_coef=2;
pSps->coef=(void*)coef_int_hpf_4000_1_2;
pSps->nx=taps_int_hpf_4000_1_2;
pSps->size_x=2;
pSps->x=(void*)(calloc(pSps->nx,pSps->size_x));
if(pSps==NULL)printf("Error: calloc(), createPmrChannel()\n");
pSps->outputGain=(1*M_Q8);
pSps->calcAdjust=gain_int_hpf_4000_1_2;
pSps->inputGain=(1*M_Q8);
pSps->outputGain=(1*M_Q8);
inputTmp=pSps->sink;
}
// Tx Limiter
if(pChan->txLimiterEnable)
{
if(pSps==NULL) pSps=pChan->spsTx=createPmrSps();
else pSps=pSps->nextSps=createPmrSps();
pSps->source=inputTmp;
pSps->sink=pChan->pTxLimiter;
pSps->sigProc=SoftLimiter;
pSps->enabled=1;
pSps->nSamples=pChan->nSamplesTx;
pSps->inputGain=(1*M_Q8);
pSps->outputGain=(1*M_Q8);
pSps->setpt=12000;
inputTmp=pSps->sink;
}
// Composite Mix of Voice and LSD
if((pChan->txMixA==TX_OUT_COMPOSITE)||(pChan->txMixB==TX_OUT_COMPOSITE))
{
if(pSps==NULL)
pSps=pChan->spsTx=createPmrSps();
else
pSps=pSps->nextSps=createPmrSps();
pSps->source=inputTmp;
pSps->sourceB=pChan->pTxLsdLpf; //asdf ??? !!! maw pTxLsdLpf
pSps->sink=pChan->pTxComposite;
pSps->sigProc=pmrMixer;
pSps->enabled=1;
pSps->nSamples=pChan->nSamplesTx;
pSps->inputGain=2*M_Q8;
pSps->inputGainB=1*M_Q8/8;
pSps->outputGain=1*M_Q8;
pSps->setpt=0;
inputTmp=pSps->sink;
pChan->ptxCtcssAdjust=&pSps->inputGainB;
}
// Chan A Upsampler and Filter
if(pSps==NULL) pSps=pChan->spsTx=createPmrSps();
else pSps=pSps->nextSps=createPmrSps();
pChan->spsTxOutA=pSps;
if(!pChan->spsTx)pChan->spsTx=pSps;
pSps->parentChan=pChan;
if(pChan->txMixA==TX_OUT_COMPOSITE)
{
pSps->source=pChan->pTxComposite;
}
else if(pChan->txMixA==TX_OUT_LSD)
{
pSps->source=pChan->pTxLsdLpf;
}
else if(pChan->txMixA==TX_OUT_VOICE)
{
pSps->source=pChan->pTxHpf;
}
else if (pChan->txMixA==TX_OUT_AUX)
{
pSps->source=inputTmp;
}
else
{
pSps->source=NULL;
}
pSps->sink=pChan->pTxOut;
pSps->sigProc=pmr_gp_fir;
pSps->enabled=1;
pSps->numChanOut=2;
pSps->selChanOut=0;
pSps->nSamples=pChan->nSamplesTx;
pSps->interpolate=6;
pSps->ncoef=taps_fir_lpf_3K_1;
pSps->size_coef=2;
pSps->coef=(void*)coef_fir_lpf_3K_1;
pSps->nx=taps_fir_lpf_3K_1;
pSps->size_x=2;
pSps->x=(void*)(calloc(pSps->nx,pSps->size_x));
if(pSps==NULL)printf("Error: calloc(), createPmrChannel()\n");
pSps->calcAdjust=gain_fir_lpf_3K_1;
pSps->inputGain=(1*M_Q8);
pSps->outputGain=(1*M_Q8);
if(pChan->txMixA==pChan->txMixB)pSps->monoOut=1;
else pSps->monoOut=0;
// Chan B Upsampler and Filter
if((pChan->txMixA!=pChan->txMixB)&&(pChan->txMixB!=TX_OUT_OFF))
{
if(pSps==NULL) pSps=pChan->spsTx=createPmrSps();
else pSps=pSps->nextSps=createPmrSps();
pChan->spsTxOutB=pSps;
pSps->parentChan=pChan;
if(pChan->txMixB==TX_OUT_COMPOSITE)
{
pSps->source=pChan->pTxComposite;
}
else if(pChan->txMixB==TX_OUT_LSD)
{
pSps->source=pChan->pTxLsdLpf;
// pChan->ptxCtcssAdjust=&pSps->inputGain;
}
else if(pChan->txMixB==TX_OUT_VOICE)
{
pSps->source=inputTmp;
}
else if(pChan->txMixB==TX_OUT_AUX)
{
pSps->source=pChan->pTxHpf;
}
else
{
pSps->source=NULL;
}
pSps->sink=pChan->pTxOut;
pSps->sigProc=pmr_gp_fir;
pSps->enabled=1;
pSps->numChanOut=2;
pSps->selChanOut=1;
pSps->mixOut=0;
pSps->nSamples=pChan->nSamplesTx;
pSps->interpolate=6;
pSps->ncoef=taps_fir_lpf_3K_1;
pSps->size_coef=2;
pSps->coef=(void*)coef_fir_lpf_3K_1;
pSps->nx=taps_fir_lpf_3K_1;
pSps->size_x=2;
pSps->x=(void*)(calloc(pSps->nx,pSps->size_x));
if(pSps==NULL)printf("Error: calloc(), createPmrChannel()\n");
pSps->calcAdjust=(gain_fir_lpf_3K_1);
pSps->inputGain=(1*M_Q8);
pSps->outputGain=(1*M_Q8);
}
pSps->nextSps=NULL;
#if XPMR_DEBUG0 == 1
{
t_tdet *ptdet;
TRACEX((" configure tracing\n"));
pChan->rxCtcss->pDebug0=calloc(numSamples,2);
pChan->rxCtcss->pDebug1=calloc(numSamples,2);
pChan->rxCtcss->pDebug2=calloc(numSamples,2);
for(i=0;i<CTCSS_NUM_CODES;i++){
ptdet=&(pChan->rxCtcss->tdet[i]);
ptdet->pDebug0=calloc(numSamples,2);
ptdet->pDebug1=calloc(numSamples,2);
ptdet->pDebug2=calloc(numSamples,2);
}
// buffer, 2 bytes per sample, and 16 channels
pChan->prxDebug=calloc(numSamples*16,2);
pChan->ptxDebug=calloc(numSamples*16,2);
}
#endif
TRACEX((" createPmrChannel() end\n"));
return pChan;
}
/*
*/
i16 destroyPmrChannel(t_pmr_chan *pChan)
{
t_pmr_sps *pmr_sps, *tmp_sps;
i16 i;
TRACEX(("destroyPmrChannel()\n"));
free(pChan->pRxDemod);
free(pChan->pRxNoise);
free(pChan->pRxBase);
free(pChan->pRxHpf);
free(pChan->pRxLsd);
free(pChan->pRxSpeaker);
free(pChan->pRxDcTrack);
if(pChan->pRxLsdLimit)free(pChan->pRxLsdLimit);
free(pChan->pTxBase);
free(pChan->pTxHpf);
free(pChan->pTxPreEmp);
free(pChan->pTxLimiter);
free(pChan->pTxLsd);
free(pChan->pTxLsdLpf);
if(pChan->pTxComposite)free(pChan->pTxComposite);
free(pChan->pTxCode);
free(pChan->pTxOut);
if(pChan->pSigGen0)free(pChan->pSigGen0);
if(pChan->pSigGen1)free(pChan->pSigGen1);
#if XPMR_DEBUG0 == 1
free(pChan->pTxPttIn);
free(pChan->pTxPttOut);
if(pChan->prxDebug)free(pChan->prxDebug);
if(pChan->ptxDebug)free(pChan->ptxDebug);
free(pChan->rxCtcss->pDebug0);
free(pChan->rxCtcss->pDebug1);
free(pChan->prxDebug0);
free(pChan->prxDebug1);
free(pChan->prxDebug2);
free(pChan->prxDebug3);
free(pChan->ptxDebug0);
free(pChan->ptxDebug1);
free(pChan->ptxDebug2);
free(pChan->ptxDebug3);
for(i=0;i<CTCSS_NUM_CODES;i++)
{
free(pChan->rxCtcss->tdet[i].pDebug0);
free(pChan->rxCtcss->tdet[i].pDebug1);
free(pChan->rxCtcss->tdet[i].pDebug2);
}
#endif
free(pChan->pRxCtcss);
pmr_sps=pChan->spsRx;
while(pmr_sps)
{
tmp_sps = pmr_sps;
pmr_sps = tmp_sps->nextSps;
destroyPmrSps(tmp_sps);
}
free(pChan);
return 0;
}
/*
*/
t_pmr_sps *createPmrSps(void)
{
t_pmr_sps *pSps;
TRACEX(("createPmrSps()\n"));
pSps = (t_pmr_sps *)calloc(sizeof(t_pmr_sps),1);
if(!pSps)printf("Error: createPmrSps()\n");
// pSps->x=calloc(pSps->nx,pSps->size_x);
return pSps;
}
/*
*/
i16 destroyPmrSps(t_pmr_sps *pSps)
{
TRACEX(("destroyPmrSps(%i)\n",pSps->index));
if(pSps->x!=NULL)free(pSps->x);
free(pSps);
return 0;
}
/*
PmrRx does the whole buffer
*/
i16 PmrRx(t_pmr_chan *pChan, i16 *input, i16 *output)
{
int i,ii;
t_pmr_sps *pmr_sps;
TRACEX(("PmrRx() %i\n",pChan->frameCountRx));
if(pChan==NULL){
printf("PmrRx() pChan == NULL\n");
return 1;
}
pChan->frameCountRx++;
pmr_sps=pChan->spsRx; // first sps
pmr_sps->source=input;
if(output!=NULL)pChan->spsRxOut->sink=output; //last sps
#if 0
if(pChan->inputBlanking>0)
{
pChan->inputBlanking-=pChan->nSamplesRx;
if(pChan->inputBlanking<0)pChan->inputBlanking=0;
for(i=0;i<pChan->nSamplesRx*6;i++)
input[i]=0;
}
#endif
// || (pChan->radioDuplex && (pChan->pttIn || pChan->pttOut)))
if(pChan->rxCpuSaver && !pChan->rxCarrierDetect)
{
if(pChan->spsRxHpf)pChan->spsRxHpf->enabled=0;
if(pChan->spsRxDeEmp)pChan->spsRxDeEmp->enabled=0;
}
else
{
if(pChan->spsRxHpf)pChan->spsRxHpf->enabled=1;
if(pChan->spsRxDeEmp)pChan->spsRxDeEmp->enabled=1;
}
i=0;
while(pmr_sps!=NULL && pmr_sps!=0)
{
TRACEX(("PmrRx() sps %i\n",i++));
pmr_sps->sigProc(pmr_sps);
pmr_sps = (t_pmr_sps *)(pmr_sps->nextSps);
//pmr_sps=NULL; // sph maw
}
#define XPMR_VOX_HANGTIME 2000
if(pChan->rxCdType==CD_XPMR_VOX)
{
if(pChan->spsRxVox->compOut)
{
pChan->rxVoxTimer=XPMR_VOX_HANGTIME; //VOX HangTime in ms
}
if(pChan->rxVoxTimer>0)
{
pChan->rxVoxTimer-=MS_PER_FRAME;
pChan->rxCarrierDetect=1;
}
else
{
pChan->rxVoxTimer=0;
pChan->rxCarrierDetect=0;
}
}
else
{
pChan->rxCarrierDetect=!pChan->spsRx->compOut;
}
if( !pChan->rxCpuSaver || pChan->rxCarrierDetect
|| pChan->rxCtcss->decode!=-1) ctcss_detect(pChan);
#if XPMR_DEBUG0 == 1
// TRACEX(("Write file.\n"));
ii=0;
if(pChan->b.rxCapture)
{
for(i=0;i<pChan->nSamplesRx;i++)
{
pChan->prxDebug[ii++]=input[i*2*6]; // input data
pChan->prxDebug[ii++]=output[i]; // output data
pChan->prxDebug[ii++]=pChan->rxCarrierDetect*M_Q14; // carrier detect
if(pChan->rxCtcss)
pChan->prxDebug[ii++]=pChan->rxCtcss->decode*M_Q15/CTCSS_NUM_CODES; // decoded ctcss
else
pChan->prxDebug[ii++]=0;
pChan->prxDebug[ii++]=pChan->pRxNoise[i]; // rssi
pChan->prxDebug[ii++]=pChan->pRxBase[i]; // decimated, low pass filtered
pChan->prxDebug[ii++]=pChan->pRxHpf[i]; // output to network
pChan->prxDebug[ii++]=pChan->pRxSpeaker[i];
pChan->prxDebug[ii++]=pChan->pRxLsd[i]; // CTCSS Filtered
pChan->prxDebug[ii++]=pChan->pRxDcTrack[i]; // DC Restoration
pChan->prxDebug[ii++]=pChan->pRxLsdLimit[i]; // Amplitude Limited
//pChan->prxDebug[ii++]=pChan->rxCtcss->tdet[pChan->rxCtcss->testIndex+1].pDebug0[i]; // Upper Adjacent CTCSS Code
pChan->prxDebug[ii++]=pChan->rxCtcss->tdet[pChan->rxCtcss->testIndex].pDebug0[i]; // Primary CTCSS Code
pChan->prxDebug[ii++]=pChan->rxCtcss->tdet[pChan->rxCtcss->testIndex].pDebug1[i]; // dv/dt of decoder output
pChan->prxDebug[ii++]=pChan->rxCtcss->tdet[pChan->rxCtcss->testIndex].pDebug2[i];
//pChan->prxDebug[ii++]=pChan->rxCtcss->tdet[pChan->rxCtcss->testIndex-1].pDebug0[i]; // Lower Adjacent CTCSS Code
pChan->prxDebug[ii++]=pChan->prxDebug1[i]; // Measure Output for VOX
pChan->prxDebug[ii++]=pChan->prxDebug2[i]; // Measure Output for Tuning
}
}
#endif
return 0;
}
/*
PmrTx does the whole buffer
*/
i16 PmrTx(t_pmr_chan *pChan, i16 *input, i16 *output)
{
int i, hit=0;
t_pmr_sps *pmr_sps;
pChan->frameCountTx++;
TRACEX(("PmrTx() %i\n",pChan->frameCountTx));
if(pChan==NULL){
printf("PmrTx() pChan == NULL\n");
return 1;
}
if(pChan->b.startSpecialTone)
{
pChan->b.startSpecialTone=0;
pChan->spsSigGen1->option=1;
pChan->spsSigGen1->enabled=1;
pChan->b.doingSpecialTone=1;
} else if(pChan->b.stopSpecialTone)
{
pChan->b.stopSpecialTone=0;
pChan->spsSigGen1->option=0;
pChan->b.doingSpecialTone=0;
pChan->spsSigGen1->enabled=0;
} else if(pChan->b.doingSpecialTone)
{
pChan->spsSigGen1->sink=output;
pChan->spsSigGen1->sigProc(pChan->spsSigGen1);
for(i=0;i<(pChan->nSamplesTx*2*6);i+=2)output[i+1]=output[i];
return 0;
}
// handle transmitter ptt input
hit=0;
if( pChan->txPttIn && pChan->txState==0)
{
pChan->txState = 2;
pChan->txPttOut=1;
pChan->spsSigGen0->freq=pChan->txCtcssFreq*10;
pChan->spsSigGen0->option=1;
pChan->spsSigGen0->enabled=1;
if(pChan->spsTxOutA)pChan->spsTxOutA->enabled=1;
if(pChan->spsTxOutB)pChan->spsTxOutB->enabled=1;
if(pChan->spsTxLsdLpf)pChan->spsTxLsdLpf->enabled=1;
TRACEX((" TxOn\n"));
}
else if(!pChan->txPttIn && pChan->txState==2)
{
if( pChan->txTocType==TOC_NONE || !pChan->txCtcssFreq )
{
hit=1;
TRACEX((" Tx Off Immediate.\n"));
}
else if(pChan->txCtcssFreq && pChan->txTocType==TOC_NOTONE)
{
pChan->txState=3;
pChan->txHangTime=TOC_NOTONE_TIME/MS_PER_FRAME;
pChan->spsSigGen0->option=3;
TRACEX((" Tx Turn Off No Tone Start.\n"));
}
else
{
pChan->txState=3;
pChan->txHangTime=0;
pChan->spsSigGen0->option=2;
TRACEX((" Tx Turn Off Phase Shift Start.\n"));
}
}
else if(pChan->txState==3)
{
if(pChan->txHangTime)
{
if(--pChan->txHangTime==0)hit=1;
}
else if(pChan->txHangTime<=0 && pChan->spsSigGen0->state==0)
{
hit=1;
TRACEX((" Tx Off TOC.\n"));
}
if(pChan->txPttIn)
{
TRACEX((" Tx Key During HangTime\n"));
if((pChan->txTocType==TOC_PHASE)||(pChan->txTocType==TOC_NONE))
{
pChan->txState = 2;
hit=0;
}
}
}
if( pChan->txCpuSaver && !hit && !pChan->txPttIn && !pChan->txPttOut && pChan->txState==0 ) return (1);
if(hit)
{
pChan->txPttOut=0;
pChan->txState=0;
if(pChan->spsTxLsdLpf)pChan->spsTxLsdLpf->option=3;
if(pChan->spsTxOutA)pChan->spsTxOutA->option=3;
if(pChan->spsTxOutB)pChan->spsTxOutB->option=3;
TRACEX((" Tx Off hit.\n"));
}
if(pChan->spsSigGen0)
{
pChan->spsSigGen0->sigProc(pChan->spsSigGen0);
pmr_sps=pChan->spsSigGen0->nextSps;
i=0;
while(pmr_sps!=NULL && pmr_sps!=0)
{
TRACEX((" PmrTx() subaudible sps %i\n",i++));
//printf(" CTCSS ENCODE %i %i\n",pChan->spsSigGen0->freq,pChan->spsSigGen0->outputGain);
pmr_sps->sigProc(pmr_sps);
pmr_sps = (t_pmr_sps *)(pmr_sps->nextSps);
}
}
if(pChan->spsSigGen1 && pChan->spsSigGen1->enabled)
{
pChan->spsSigGen1->sigProc(pChan->spsSigGen1);
}
// Do Voice
pmr_sps=pChan->spsTx;
if(!pChan->spsSigGen1->enabled)pmr_sps->source=input;
else input=pmr_sps->source;
if(output!=NULL)
{
if(pChan->spsTxOutA)pChan->spsTxOutA->sink=output;
if(pChan->spsTxOutB)pChan->spsTxOutB->sink=output;
}
i=0;
while(pmr_sps!=NULL && pmr_sps!=0)
{
TRACEX((" PmrTx() sps %i\n",i++));
pmr_sps->sigProc(pmr_sps);
pmr_sps = (t_pmr_sps *)(pmr_sps->nextSps);
}
if(pChan->txMixA==TX_OUT_OFF || !pChan->txPttOut){
for(i=0;i<pChan->nSamplesTx*2*6;i+=2)output[i]=0;
}
if(pChan->txMixB==TX_OUT_OFF || !pChan->txPttOut ){
for(i=0;i<pChan->nSamplesTx*2*6;i+=2)output[i+1]=0;
}
#if XPMR_DEBUG0 == 1
if(pChan->b.txCapture)
{
i16 ii=0;
for(i=0;i<pChan->nSamplesTx;i++)
{
pChan->ptxDebug[ii++]=input[i];
pChan->ptxDebug[ii++]=output[i*2*6];
pChan->ptxDebug[ii++]=output[(i*2*6)+1];
pChan->ptxDebug[ii++]=pChan->txPttIn*8192;
pChan->ptxDebug[ii++]=pChan->txPttOut*8192;
if(pChan->txHpfEnable)pChan->ptxDebug[ii++]=pChan->pTxHpf[i];
else pChan->ptxDebug[ii++]=0;
if(pChan->txPreEmpEnable)pChan->ptxDebug[ii++]=pChan->pTxPreEmp[i];
else pChan->ptxDebug[ii++]=0;
if(pChan->txLimiterEnable)pChan->ptxDebug[ii++]=pChan->pTxLimiter[i];
else pChan->ptxDebug[ii++]=0;
pChan->ptxDebug[ii++]=pChan->pTxLsd[i];
pChan->ptxDebug[ii++]=pChan->pTxLsdLpf[i];
pChan->ptxDebug[ii++]=pChan->pTxComposite[i];
pChan->ptxDebug[ii++]=pChan->pSigGen1[i];
#if 1
pChan->ptxDebug[ii++]=pChan->ptxDebug0[i];
pChan->ptxDebug[ii++]=pChan->ptxDebug1[i];
pChan->ptxDebug[ii++]=pChan->ptxDebug2[i];
pChan->ptxDebug[ii++]=pChan->ptxDebug3[i];
#else
pChan->ptxDebug[ii++]=0;
pChan->ptxDebug[ii++]=0;
pChan->ptxDebug[ii++]=0;
pChan->ptxDebug[ii++]=0;
#endif
}
}
#endif
return 0;
}
/* end of file */
Reference in new issue View Git Blame Copy Permalink