?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Optionally display the value of several variables within the Status command.
[asterisk-bristuff.git] / channels / xpmr / xpmr.c
bloba799ca9d38123a9d2593a5d9cd961fec87e4890e
1 /*
2 * xpmr.c - Xelatec Private Mobile Radio Processes
3 *
4 * All Rights Reserved. Copyright (C)2007, Xelatec, LLC
5 *
6 * 20070808 1235 Steven Henke, W9SH, sph@xelatec.com
7 *
8 * See http://www.asterisk.org for more information about
9 * the Asterisk project. Please do not directly contact
10 * any of the maintainers of this project for assistance;
11 * the project provides a web site, mailing lists and IRC
12 * channels for your use.
13 *
14 * This program is free software, distributed under the terms of
15 * the GNU General Public License Version 2. See the LICENSE file
16 * at the top of the source tree.
17 */
18
19 /*! \file
20 *
21 * \brief Private Land Mobile Radio Channel Voice and Signaling Processor
22 *
23 * \author Steven Henke, W9SH <sph@xelatec.com> Xelatec, LLC
24 */
25 /*
26 FYI = For Your Information
27 PMR = Private Mobile Radio
28 RX = Receive
29 TX = Transmit
30 CTCSS = Continuous Tone Coded Squelch System
31 TONE = Same as above.
32 LSD = Low Speed Data, subaudible signaling. May be tones or codes.
33 VOX = Voice Operated Transmit
34 DSP = Digital Signal Processing
35 LPF = Low Pass Filter
36 FIR = Finite Impulse Response (Filter)
37 IIR = Infinite Impulse Response (Filter)
38 */
39 #include <stdio.h>
40 #include <ctype.h>
41 #include <math.h>
42 #include <string.h>
43 #include <unistd.h>
44 #include <sys/ioctl.h>
45 #include <fcntl.h>
46 #include <sys/time.h>
47 #include <stdlib.h>
48 #include <errno.h>
49
50 #include "xpmr.h"
51 #include "xpmr_coef.h"
52 #include "sinetabx.h"
53
54 static i16 pmrChanIndex=0; // count of created pmr instances
55
56 /*
57 Convert a Frequency in Hz to a zero based CTCSS Table index
58 */
59 i16 CtcssFreqIndex(float freq)
60 {
61 i16 i,hit=-1;
62
63 for(i=0;i<CTCSS_NUM_CODES;i++){
64 if(freq==freq_ctcss[i])hit=i;
65 }
66 return hit;
67 }
68 /*
69 pmr_rx_frontend
70 Takes a block of data and low pass filters it.
71 Determines the amplitude of high frequency noise for carrier detect.
72 Decimates input data to change the rate.
73 */
74 i16 pmr_rx_frontend(t_pmr_sps *mySps)
75 {
76 #define DCgainBpfNoise 65536
77
78 i16 samples,iOutput, *input, *output, *noutput;
79 i16 *x, *coef, *coef2;
80 i32 i, naccum, outputGain, calcAdjust;
81 i64 y;
82 i16 nx, hyst, setpt, compOut;
83 i16 amax, amin, apeak, discounteru, discounterl, discfactor;
84 i16 decimator, decimate, doNoise;
85
86 TRACEX(("pmr_rx_frontend()\n"));
87
88 if(!mySps->enabled)return(1);
89
90 decimator = mySps->decimator;
91 decimate = mySps->decimate;
92
93 input = mySps->source;
94 output = mySps->sink;
95 noutput = mySps->parentChan->pRxNoise;
96
97 nx = mySps->nx;
98 coef = mySps->coef;
99 coef2 = mySps->coef2;
100
101 calcAdjust = mySps->calcAdjust;
102 outputGain = mySps->outputGain;
103
104 amax=mySps->amax;
105 amin=mySps->amin;
106 apeak=mySps->apeak;
107 discounteru=mySps->discounteru;
108 discounterl=mySps->discounterl;
109 discfactor=mySps->discfactor;
110 setpt=mySps->setpt;
111 hyst=mySps->hyst;
112 compOut=mySps->compOut;
113
114 samples=mySps->nSamples*decimate;
115 x=mySps->x;
116 iOutput=0;
117
118 if(mySps->parentChan->rxCdType!=CD_XPMR_VOX)doNoise=1;
119 else doNoise=0;
120
121 for(i=0;i<samples;i++)
122 {
123 i16 n;
124
125 //shift the old samples
126 for(n=nx-1; n>0; n--)
127 x[n] = x[n-1];
128
129 x[0] = input[i*2];
130
131 --decimator;
132
133 if(decimator<=0)
134 {
135 decimator=decimate;
136
137 y=0;
138 for(n=0; n<nx; n++)
139 y += coef[n] * x[n];
140
141 y=((y/calcAdjust)*outputGain)/M_Q8;
142
143 if(y>32767)y=32767;
144 else if(y<-32767)y=-32767;
145
146 output[iOutput]=y; // Rx Baseband decimated
147 noutput[iOutput++] = apeak; // Rx Noise
148 }
149
150 if(doNoise)
151 {
152 // calculate noise output
153 naccum=0;
154 for(n=0; n<nx; n++)
155 naccum += coef_fir_bpf_noise_1[n] * x[n];
156
157 naccum /= DCgainBpfNoise;
158
159 if(naccum>amax)
160 {
161 amax=naccum;
162 discounteru=discfactor;
163 }
164 else if(--discounteru<=0)
165 {
166 discounteru=discfactor;
167 amax=(i32)((amax*32700)/32768);
168 }
169
170 if(naccum<amin)
171 {
172 amin=naccum;
173 discounterl=discfactor;
174 }
175 else if(--discounterl<=0)
176 {
177 discounterl=discfactor;
178 amin=(i32)((amin*32700)/32768);
179 }
180
181 apeak=(amax-amin)/2;
182
183 } // if doNoise
184 }
185
186 if(doNoise)
187 {
188 ((t_pmr_chan *)(mySps->parentChan))->rxRssi=apeak;
189
190 if(apeak>setpt || (compOut&&(apeak>(setpt-hyst)))) compOut=1;
191 else compOut=0;
192 mySps->compOut=compOut;
193 mySps->amax=amax;
194 mySps->amin=amin;
195 mySps->apeak=apeak;
196 mySps->discounteru=discounteru;
197 mySps->discounterl=discounterl;
198 }
199
200 return 0;
201 }
202 /*
203 pmr general purpose fir
204 works on a block of samples
205 */
206 i16 pmr_gp_fir(t_pmr_sps *mySps)
207 {
208 i32 nsamples,inputGain,outputGain,calcAdjust;
209 i16 *input, *output;
210 i16 *x, *coef;
211 i32 i, ii;
212 i16 nx, hyst, setpt, compOut;
213 i16 amax, amin, apeak=0, discounteru=0, discounterl=0, discfactor;
214 i16 decimator, decimate, interpolate;
215 i16 numChanOut, selChanOut, mixOut, monoOut;
216
217 TRACEX(("pmr_gp_fir() %i\n",mySps->enabled));
218
219 if(!mySps->enabled)return(1);
220
221 inputGain = mySps->inputGain;
222 calcAdjust = mySps->calcAdjust;
223 outputGain = mySps->outputGain;
224
225 input = mySps->source;
226 output = mySps->sink;
227 x = mySps->x;
228 nx = mySps->nx;
229 coef = mySps->coef;
230
231 decimator = mySps->decimator;
232 decimate = mySps->decimate;
233 interpolate = mySps->interpolate;
234
235 setpt = mySps->setpt;
236 compOut = mySps->compOut;
237
238 inputGain = mySps->inputGain;
239 outputGain = mySps->outputGain;
240 numChanOut = mySps->numChanOut;
241 selChanOut = mySps->selChanOut;
242 mixOut = mySps->mixOut;
243 monoOut = mySps->monoOut;
244
245 amax=mySps->amax;
246 amin=mySps->amin;
247
248 discfactor=mySps->discfactor;
249 hyst=mySps->hyst;
250 setpt=mySps->setpt;
251 nsamples=mySps->nSamples;
252
253 if(mySps->option==3)
254 {
255 mySps->option=0;
256 mySps->enabled=0;
257 for(i=0;i<nsamples;i++)
258 {
259 if(monoOut)
260 output[(i*2)]=output[(i*2)+1]=0;
261 else
262 output[(i*numChanOut)+selChanOut]=0;
263 }
264 return 0;
265 }
266
267 ii=0;
268 for(i=0;i<nsamples;i++)
269 {
270 int ix;
271
272 int64_t y=0;
273
274 if(decimate<0)
275 {
276 decimator=decimate;
277 }
278
279 for(ix=0;ix<interpolate;ix++)
280 {
281 i16 n;
282 y=0;
283
284 for(n=nx-1; n>0; n--)
285 x[n] = x[n-1];
286 x[0] = (input[i]*inputGain)/M_Q8;
287
288 #if 0
289 --decimator;
290 if(decimator<=0)
291 {
292 decimator=decimate;
293 for(n=0; n<nx; n++)
294 y += coef[n] * x[n];
295 y /= (outputGain*3);
296 output[ii++]=y;
297 }
298 #else
299 for(n=0; n<nx; n++)
300 y += coef[n] * x[n];
301
302 y=((y/calcAdjust)*outputGain)/M_Q8;
303
304 if(mixOut){
305 if(monoOut){
306 output[(ii*2)]=output[(ii*2)+1]+=y;
307 }
308 else{
309 output[(ii*numChanOut)+selChanOut]+=y;
310 }
311 }
312 else{
313 if(monoOut){
314 output[(ii*2)]=output[(ii*2)+1]=y;
315 }
316 else{
317 output[(ii*numChanOut)+selChanOut]=y;
318 }
319 }
320 ii++;
321 #endif
322 }
323
324 // amplitude detector
325 if(setpt)
326 {
327 i16 accum=y;
328
329 if(accum>amax)
330 {
331 amax=accum;
332 discounteru=discfactor;
333 }
334 else if(--discounteru<=0)
335 {
336 discounteru=discfactor;
337 amax=(i32)((amax*32700)/32768);
338 }
339
340 if(accum<amin)
341 {
342 amin=accum;
343 discounterl=discfactor;
344 }
345 else if(--discounterl<=0)
346 {
347 discounterl=discfactor;
348 amin=(i32)((amin*32700)/32768);
349 }
350
351 apeak = (i32)(amax-amin)/2;
352
353 if(apeak>setpt)compOut=1;
354 else if(compOut&&(apeak<(setpt-hyst)))compOut=0;
355 }
356 }
357
358 mySps->decimator = decimator;
359
360 mySps->amax=amax;
361 mySps->amin=amin;
362 mySps->apeak=apeak;
363 mySps->discounteru=discounteru;
364 mySps->discounterl=discounterl;
365
366 mySps->compOut=compOut;
367
368 return 0;
369 }
370 /*
371 general purpose integrator lpf
372 */
373 i16 gp_inte_00(t_pmr_sps *mySps)
374 {
375 i16 npoints;
376 i16 *input, *output;
377
378 i32 inputGain, outputGain,calcAdjust;
379 i32 i;
380 i32 accum;
381
382 i32 state00;
383 i16 coeff00, coeff01;
384
385 TRACEX(("gp_inte_00() %i\n",mySps->enabled));
386 if(!mySps->enabled)return(1);
387
388 input = mySps->source;
389 output = mySps->sink;
390
391 npoints=mySps->nSamples;
392
393 inputGain=mySps->inputGain;
394 outputGain=mySps->outputGain;
395 calcAdjust=mySps->calcAdjust;
396
397 coeff00=((i16*)mySps->coef)[0];
398 coeff01=((i16*)mySps->coef)[1];
399 state00=((i32*)mySps->x)[0];
400
401 // note fixed gain of 2 to compensate for attenuation
402 // in passband
403
404 for(i=0;i<npoints;i++)
405 {
406 accum=input[i];
407 state00 = accum + (state00*coeff01)/M_Q15;
408 accum = (state00*coeff00)/(M_Q15/4);
409 output[i]=(accum*outputGain)/M_Q8;
410 }
411
412 ((i32*)(mySps->x))[0]=state00;
413
414 return 0;
415 }
416 /*
417 general purpose differentiator hpf
418 */
419 i16 gp_diff(t_pmr_sps *mySps)
420 {
421 i16 *input, *output;
422 i16 npoints;
423 i32 inputGain, outputGain, calcAdjust;
424 i32 i;
425 i32 temp0,temp1;
426 i16 x0;
427 i32 y0;
428 i16 a0,a1;
429 i16 b0;
430 i16 *coef;
431 i16 *x;
432
433 input = mySps->source;
434 output = mySps->sink;
435
436 npoints=mySps->nSamples;
437
438 inputGain=mySps->inputGain;
439 outputGain=mySps->outputGain;
440 calcAdjust=mySps->calcAdjust;
441
442 coef=(i16*)(mySps->coef);
443 x=(i16*)(mySps->x);
444 a0=coef[0];
445 a1=coef[1];
446 b0=coef[2];
447
448 x0=x[0];
449
450 TRACEX(("gp_diff()\n"));
451
452 for (i=0;i<npoints;i++)
453 {
454 temp0 = x0 * a1;
455 x0 = input[i];
456 temp1 = input[i] * a0;
457 y0 = (temp0 + temp1)/calcAdjust;
458 output[i]=(y0*outputGain)/M_Q8;
459 }
460
461 x[0]=x0;
462
463 return 0;
464 }
465 /* ----------------------------------------------------------------------
466 CenterSlicer
467 */
468 i16 CenterSlicer(t_pmr_sps *mySps)
469 {
470 i16 npoints,lhit,uhit;
471 i16 *input, *output, *buff;
472
473 i32 inputGain, outputGain, inputGainB;
474 i32 i;
475 i32 accum;
476
477 i32 amax; // buffer amplitude maximum
478 i32 amin; // buffer amplitude minimum
479 i32 apeak; // buffer amplitude peak
480 i32 center;
481 i32 setpt; // amplitude set point for peak tracking
482
483 i32 discounteru; // amplitude detector integrator discharge counter upper
484 i32 discounterl; // amplitude detector integrator discharge counter lower
485 i32 discfactor; // amplitude detector integrator discharge factor
486
487 TRACEX(("CenterSlicer() %i\n",mySps->enabled));
488
489 input = mySps->source;
490 output = mySps->sink;
491 buff = mySps->buff;
492
493 npoints=mySps->nSamples;
494
495 inputGain=mySps->inputGain;
496 outputGain=mySps->outputGain;
497 inputGainB=mySps->inputGainB;
498
499 amax=mySps->amax;
500 amin=mySps->amin;
501 setpt=mySps->setpt;
502 apeak=mySps->apeak;
503 discounteru=mySps->discounteru;
504 discounterl=mySps->discounterl;
505
506 discfactor=mySps->discfactor;
507 npoints=mySps->nSamples;
508
509 for(i=0;i<npoints;i++)
510 {
511 accum=input[i];
512
513 lhit=uhit=0;
514
515 if(accum>amax)
516 {
517 amax=accum;
518 uhit=1;
519 if(amin<(amax-setpt))
520 {
521 amin=(amax-setpt);
522 lhit=1;
523 }
524 }
525 else if(accum<amin)
526 {
527 amin=accum;
528 lhit=1;
529 if(amax>(amin+setpt))
530 {
531 amax=(amin+setpt);
532 uhit=1;
533 }
534 }
535
536 if(--discounteru<=0 && amax>0)
537 {
538 amax--;
539 uhit=1;
540 }
541
542 if(--discounterl<=0 && amin<0)
543 {
544 amin++;
545 lhit=1;
546 }
547
548 if(uhit)discounteru=discfactor;
549 if(lhit)discounterl=discfactor;
550
551 apeak = (amax-amin)/2;
552 center = (amax+amin)/2;
553 accum = accum - center;
554 output[i]=accum;
555
556 // do limiter function
557 if(accum>inputGainB)accum=inputGainB;
558 else if(accum<-inputGainB)accum=-inputGainB;
559 buff[i]=accum;
560
561 #if XPMR_DEBUG0 == 1
562 #if 0
563 mySps->debugBuff0[i]=center;
564 #endif
565 #if 0
566 if(mySps->parentChan->frameCountRx&0x01) mySps->parentChan->prxDebug1[i]=amax;
567 else mySps->parentChan->prxDebug1[i]=amin;
568 #endif
569 #endif
570 }
571
572 mySps->amax=amax;
573 mySps->amin=amin;
574 mySps->apeak=apeak;
575 mySps->discounteru=discounteru;
576 mySps->discounterl=discounterl;
577
578 return 0;
579 }
580 /* ----------------------------------------------------------------------
581 MeasureBlock
582 determine peak amplitude
583 */
584 i16 MeasureBlock(t_pmr_sps *mySps)
585 {
586 i16 npoints;
587 i16 *input, *output;
588
589 i32 inputGain, outputGain;
590 i32 i;
591 i32 accum;
592
593 i16 amax; // buffer amplitude maximum
594 i16 amin; // buffer amplitude minimum
595 i16 apeak=0; // buffer amplitude peak (peak to peak)/2
596 i16 setpt; // amplitude set point for amplitude comparator
597
598 i32 discounteru; // amplitude detector integrator discharge counter upper
599 i32 discounterl; // amplitude detector integrator discharge counter lower
600 i32 discfactor; // amplitude detector integrator discharge factor
601
602 TRACEX(("MeasureBlock() %i\n",mySps->enabled));
603
604 if(!mySps->enabled)return 1;
605
606 if(mySps->option==3)
607 {
608 mySps->amax = mySps->amin = mySps->apeak = \
609 mySps->discounteru = mySps->discounterl = \
610 mySps->enabled = 0;
611 return 1;
612 }
613
614 input = mySps->source;
615 output = mySps->sink;
616
617 npoints=mySps->nSamples;
618
619 inputGain=mySps->inputGain;
620 outputGain=mySps->outputGain;
621
622 amax=mySps->amax;
623 amin=mySps->amin;
624 setpt=mySps->setpt;
625 discounteru=mySps->discounteru;
626 discounterl=mySps->discounterl;
627
628 discfactor=mySps->discfactor;
629 npoints=mySps->nSamples;
630
631 for(i=0;i<npoints;i++)
632 {
633 accum=input[i];
634
635 if(accum>amax)
636 {
637 amax=accum;
638 discounteru=discfactor;
639 }
640 else if(--discounteru<=0)
641 {
642 discounteru=discfactor;
643 amax=(i32)((amax*32700)/32768);
644 }
645
646 if(accum<amin)
647 {
648 amin=accum;
649 discounterl=discfactor;
650 }
651 else if(--discounterl<=0)
652 {
653 discounterl=discfactor;
654 amin=(i32)((amin*32700)/32768);
655 }
656
657 apeak = (i32)(amax-amin)/2;
658 if(output)output[i]=apeak;
659 }
660
661 mySps->amax=amax;
662 mySps->amin=amin;
663 mySps->apeak=apeak;
664 mySps->discounteru=discounteru;
665 mySps->discounterl=discounterl;
666 if(apeak>=setpt) mySps->compOut=1;
667 else mySps->compOut=0;
668
669 //TRACEX((" -MeasureBlock()=%i\n",mySps->apeak));
670 return 0;
671 }
672 /*
673 SoftLimiter
674 */
675 i16 SoftLimiter(t_pmr_sps *mySps)
676 {
677 i16 npoints;
678 //i16 samples, lhit,uhit;
679 i16 *input, *output;
680
681 i32 inputGain, outputGain;
682 i32 i;
683 i32 accum;
684 i32 tmp;
685
686 i32 amax; // buffer amplitude maximum
687 i32 amin; // buffer amplitude minimum
688 //i32 apeak; // buffer amplitude peak
689 i32 setpt; // amplitude set point for amplitude comparator
690 i16 compOut; // amplitude comparator output
691
692 input = mySps->source;
693 output = mySps->sink;
694
695 inputGain=mySps->inputGain;
696 outputGain=mySps->outputGain;
697
698 npoints=mySps->nSamples;
699
700 setpt=mySps->setpt;
701 amax=(setpt*124)/128;
702 amin=-amax;
703
704 TRACEX(("SoftLimiter() %i %i %i) \n",amin, amax,setpt));
705
706 for(i=0;i<npoints;i++)
707 {
708 accum=input[i];
709 //accum=input[i]*mySps->inputGain/256;
710
711 if(accum>setpt)
712 {
713 tmp=((accum-setpt)*4)/128;
714 accum=setpt+tmp;
715 if(accum>amax)accum=amax;
716 compOut=1;
717 accum=setpt;
718 }
719 else if(accum<-setpt)
720 {
721 tmp=((accum+setpt)*4)/128;
722 accum=(-setpt)-tmp;
723 if(accum<amin)accum=amin;
724 compOut=1;
725 accum=-setpt;
726 }
727
728 output[i]=(accum*outputGain)/M_Q8;
729 }
730
731 return 0;
732 }
733 /*
734 SigGen() - sine, square function generator
735 sps overloaded values
736 discfactor = phase factor
737 discfactoru = phase index
738 if source is not NULL then mix it in!
739
740 sign table and output gain are in Q15 format (32767=.999)
741 */
742 i16 SigGen(t_pmr_sps *mySps)
743 {
744 #define PH_FRACT_FACT 128
745
746 i32 ph;
747 i16 i,outputgain,waveform,numChanOut,selChanOut;
748 i32 accum;
749
750 TRACEX(("SigGen(%i) \n",mySps->option));
751
752 if(!mySps->freq ||!mySps->enabled)return 0;
753
754 outputgain=mySps->outputGain;
755 waveform=0;
756 numChanOut=mySps->numChanOut;
757 selChanOut=mySps->selChanOut;
758
759 if(mySps->option==1)
760 {
761 mySps->option=0;
762 mySps->state=1;
763 mySps->discfactor=
764 (SAMPLES_PER_SINE*mySps->freq*PH_FRACT_FACT)/mySps->sampleRate/10;
765
766 TRACEX((" SigGen() discfactor = %i\n",mySps->discfactor));
767 if(mySps->discounterl)mySps->state=2;
768 }
769 else if(mySps->option==2)
770 {
771 i16 shiftfactor=CTCSS_TURN_OFF_SHIFT;
772 // phase shift request
773 mySps->option=0;
774 mySps->state=2;
775 mySps->discounterl=CTCSS_TURN_OFF_TIME-(2*MS_PER_FRAME); //
776
777 mySps->discounteru = \
778 (mySps->discounteru + (((SAMPLES_PER_SINE*shiftfactor)/360)*PH_FRACT_FACT)) % (SAMPLES_PER_SINE*PH_FRACT_FACT);
779 //printf("shiftfactor = %i\n",shiftfactor);
780 //shiftfactor+=10;
781 }
782 else if(mySps->option==3)
783 {
784 // stop it and clear the output buffer
785 mySps->option=0;
786 mySps->state=0;
787 mySps->enabled=0;
788 for(i=0;i<mySps->nSamples;i++)
789 mySps->sink[(i*numChanOut)+selChanOut]=0;
790 return(0);
791 }
792 else if(mySps->state==2)
793 {
794 // doing turn off
795 mySps->discounterl-=MS_PER_FRAME;
796 if(mySps->discounterl<=0)
797 {
798 mySps->option=3;
799 mySps->state=2;
800 }
801 }
802 else if(mySps->state==0)
803 {
804 return(0);
805 }
806
807 ph=mySps->discounteru;
808
809 for(i=0;i<mySps->nSamples;i++)
810 {
811 if(!waveform)
812 {
813 // sine
814 //tmp=(sinetablex[ph/PH_FRACT_FACT]*amplitude)/M_Q16;
815 accum=sinetablex[ph/PH_FRACT_FACT];
816 accum=(accum*outputgain)/M_Q8;
817 }
818 else
819 {
820 // square
821 if(ph>SAMPLES_PER_SINE/2)
822 accum=outputgain/M_Q8;
823 else
824 accum=-outputgain/M_Q8;
825 }
826
827 if(mySps->source)accum+=mySps->source[i];
828
829 mySps->sink[(i*numChanOut)+selChanOut]=accum;
830
831 ph=(ph+mySps->discfactor)%(SAMPLES_PER_SINE*PH_FRACT_FACT);
832 }
833
834 mySps->discounteru=ph;
835
836 return 0;
837 }
838 /*
839 adder/mixer
840 takes existing buffer and adds source buffer to destination buffer
841 sink buffer = (sink buffer * gain) + source buffer
842 */
843 i16 pmrMixer(t_pmr_sps *mySps)
844 {
845 i32 accum;
846 i16 i, *input, *inputB, *output;
847 i16 inputGain, inputGainB; // apply to input data in Q7.8 format
848 i16 outputGain; // apply to output data in Q7.8 format
849 i16 discounteru,discounterl,amax,amin,setpt,discfactor;
850 i16 npoints,uhit,lhit,apeak,measPeak;
851
852 TRACEX(("pmrMixer()\n"));
853
854 input = mySps->source;
855 inputB = mySps->sourceB;
856 output = mySps->sink;
857
858 inputGain=mySps->inputGain;
859 inputGainB=mySps->inputGainB;
860 outputGain=mySps->outputGain;
861
862 amax=mySps->amax;
863 amin=mySps->amin;
864 setpt=mySps->setpt;
865 discounteru=mySps->discounteru;
866 discounterl=mySps->discounteru;
867
868 discfactor=mySps->discfactor;
869 npoints=mySps->nSamples;
870 measPeak=mySps->measPeak;
871
872 for(i=0;i<npoints;i++)
873 {
874 accum = ((input[i]*inputGain)/M_Q8) +
875 ((inputB[i]*inputGainB)/M_Q8);
876
877 accum=(accum*outputGain)/M_Q8;
878 output[i]=accum;
879
880 if(measPeak){
881 lhit=uhit=0;
882
883 if(accum>amax){
884 amax=accum;
885 uhit=1;
886 if(amin<(amax-setpt)){
887 amin=(amax-setpt);
888 lhit=1;
889 }
890 }
891 else if(accum<amin){
892 amin=accum;
893 lhit=1;
894 if(amax>(amin+setpt)){
895 amax=(amin+setpt);
896 uhit=1;
897 }
898 }
899
900 if(--discounteru<=0 && amax>0){
901 amax--;
902 uhit=1;
903 }
904
905 if(--discounterl<=0 && amin<0){
906 amin++;
907 lhit=1;
908 }
909
910 if(uhit)discounteru=discfactor;
911 if(lhit)discounterl=discfactor;
912 }
913 }
914
915 if(measPeak){
916 apeak = (amax-amin)/2;
917 mySps->apeak=apeak;
918 mySps->amax=amax;
919 mySps->amin=amin;
920 mySps->discounteru=discounteru;
921 mySps->discounterl=discounterl;
922 }
923
924 return 0;
925 }
926 /*
927 DelayLine
928 */
929 i16 DelayLine(t_pmr_sps *mySps)
930 {
931 i16 *input, *output, *buff;
932 i16 i, npoints,buffsize,inindex,outindex;
933
934 TRACEX((" DelayLine() %i\n",mySps->enabled));
935
936 input = mySps->source;
937 output = mySps->sink;
938 buff = (i16*)(mySps->buff);
939 buffsize = mySps->buffSize;
940 npoints = mySps->nSamples;
941
942 outindex = mySps->buffOutIndex;
943 inindex = outindex + mySps->buffLead;
944
945 for(i=0;i<npoints;i++)
946 {
947 inindex %= buffsize;
948 outindex %= buffsize;
949
950 buff[inindex]=input[i];
951 output[i]=buff[outindex];
952 inindex++;
953 outindex++;
954 }
955 mySps->buffOutIndex=outindex;
956
957 return 0;
958 }
959 /*
960 Continuous Tone Coded Squelch (CTCSS) Detector
961 */
962 i16 ctcss_detect(t_pmr_chan *pmrChan)
963 {
964 i16 i,points2do, points=0, *pInput, hit, thit,relax;
965 i16 tnum, tmp, indexWas=0, indexNow, gain, peakwas=0, diffpeak;
966 i16 difftrig;
967 i16 lasttv0=0, lasttv1=0, lasttv2=0, tv0, tv1, tv2, indexDebug;
968
969 TRACEX(("ctcss_detect(%p) %i %i %i %i\n",pmrChan,
970 pmrChan->rxCtcss->enabled,
971 pmrChan->rxCtcssIndex,
972 pmrChan->rxCtcss->testIndex,
973 pmrChan->rxCtcss->decode));
974
975 if(!pmrChan->rxCtcss->enabled)return(1);
976
977 relax = pmrChan->rxCtcss->relax;
978 pInput = pmrChan->rxCtcss->input;
979 gain = pmrChan->rxCtcss->gain;
980
981 if(relax) difftrig=(-0.1*M_Q15);
982 else difftrig=(-0.05*M_Q15);
983
984 thit=hit=-1;
985
986 //TRACEX((" ctcss_detect() %i %i %i %i\n", CTCSS_NUM_CODES,0,0,0));
987
988 for(tnum=0;tnum<CTCSS_NUM_CODES;tnum++)
989 {
990 i32 accum, peak;
991 t_tdet *ptdet;
992 i16 fudgeFactor;
993 i16 binFactor;
994
995 //TRACEX((" ctcss_detect() tnum=%i %i\n",tnum,pmrChan->rxCtcssMap[tnum]));
996
997 if( (pmrChan->rxCtcssMap[tnum] < 0) ||
998 (pmrChan->rxCtcss->decode>=0 && (tnum!= pmrChan->rxCtcss->decode)) ||
999 (!pmrChan->rxCtcss->multiFreq && (tnum!= pmrChan->rxCtcssIndex))
1000 )
1001 continue;
1002
1003 //TRACEX((" ctcss_detect() tnum=%i\n",tnum));
1004
1005 ptdet=&(pmrChan->rxCtcss->tdet[tnum]);
1006 indexDebug=0;
1007 points=points2do=pmrChan->nSamplesRx;
1008 fudgeFactor=ptdet->fudgeFactor;
1009 binFactor=ptdet->binFactor;
1010
1011 while(ptdet->counter < (points2do*CTCSS_SCOUNT_MUL))
1012 {
1013 //TRACEX((" ctcss_detect() - inner loop\n"));
1014 tmp=(ptdet->counter/CTCSS_SCOUNT_MUL)+1;
1015 ptdet->counter-=(tmp*CTCSS_SCOUNT_MUL);
1016 points2do-=tmp;
1017 indexNow=points-points2do;
1018
1019 ptdet->counter += ptdet->counterFactor;
1020
1021 accum = pInput[indexNow-1]; // dude's major bug fix!
1022
1023 peakwas=ptdet->peak;
1024
1025 ptdet->z[ptdet->zIndex]+=
1026 (((accum - ptdet->z[ptdet->zIndex])*binFactor)/M_Q15);
1027
1028 peak = abs(ptdet->z[0]-ptdet->z[2]) + abs(ptdet->z[1]-ptdet->z[3]);
1029
1030 if (ptdet->peak < peak)
1031 ptdet->peak += ( ((peak-ptdet->peak)*binFactor)/M_Q15);
1032 else
1033 ptdet->peak=peak;
1034
1035 {
1036 static const i16 a0=13723;
1037 static const i16 a1=-13723;
1038 i32 temp0,temp1;
1039 i16 x0;
1040
1041 //differentiate
1042 x0=ptdet->zd;
1043 temp0 = x0 * a1;
1044 ptdet->zd = ptdet->peak;
1045 temp1 = ptdet->peak * a0;
1046 diffpeak = (temp0 + temp1)/1024;
1047 }
1048
1049 if(diffpeak<(-0.03*M_Q15))ptdet->dvd-=4;
1050 else if(ptdet->dvd<0)ptdet->dvd++;
1051
1052 if((ptdet->dvd < -12) && diffpeak > (-0.02*M_Q15))ptdet->dvu+=2;
1053 else if(ptdet->dvu)ptdet->dvu--;
1054
1055 tmp=ptdet->setpt;
1056 if(pmrChan->rxCtcss->decode==tnum)
1057 {
1058 if(relax)tmp=(tmp*55)/100;
1059 else tmp=(tmp*80)/100;
1060 }
1061
1062 if(ptdet->peak > tmp)
1063 {
1064 if(ptdet->decode<(fudgeFactor*32))ptdet->decode++;
1065 }
1066 else if(pmrChan->rxCtcss->decode==tnum)
1067 {
1068 if(ptdet->peak > ptdet->hyst)ptdet->decode--;
1069 else if(relax) ptdet->decode--;
1070 else ptdet->decode-=4;
1071 }
1072 else
1073 {
1074 ptdet->decode=0;
1075 }
1076
1077 if((pmrChan->rxCtcss->decode==tnum) && !relax && (ptdet->dvu > (0.00075*M_Q15)))
1078 {
1079 ptdet->decode=0;
1080 ptdet->z[0]=ptdet->z[1]=ptdet->z[2]=ptdet->z[3]=ptdet->dvu=0;
1081 //printf("ctcss_detect() turnoff code!\n");
1082 }
1083
1084 if(ptdet->decode<0 || !pmrChan->rxCarrierDetect)ptdet->decode=0;
1085
1086 if(ptdet->decode>=fudgeFactor)thit=tnum;
1087
1088 #if XPMR_DEBUG0 == 1
1089 //if(thit>=0 && thit==tnum)
1090 // printf(" ctcss_detect() %i %i %i %i \n",tnum,ptdet->peak,ptdet->setpt,ptdet->hyst);
1091
1092 // tv0=accum;
1093 tv0=ptdet->peak;
1094 tv1=diffpeak;
1095 tv2=ptdet->dvu;
1096
1097 //tv1=ptdet->zi*100;
1098 while(indexDebug<indexNow)
1099 {
1100 if(indexDebug==0)lasttv0=ptdet->pDebug0[points-1];
1101 if(ptdet->pDebug0)ptdet->pDebug0[indexDebug]=lasttv0;
1102
1103 if(indexDebug==0)lasttv1=ptdet->pDebug1[points-1];
1104 if(ptdet->pDebug1)ptdet->pDebug1[indexDebug]=lasttv1;
1105
1106 if(indexDebug==0)lasttv2=ptdet->pDebug2[points-1];
1107 if(ptdet->pDebug2)ptdet->pDebug2[indexDebug]=lasttv2;
1108
1109 indexDebug++;
1110 }
1111 lasttv0=tv0;
1112 lasttv1=tv1;
1113 lasttv2=tv2*100;
1114 #endif
1115 indexWas=indexNow;
1116 ptdet->zIndex=(++ptdet->zIndex)%4;
1117 }
1118 ptdet->counter-=(points2do*CTCSS_SCOUNT_MUL);
1119
1120 #if XPMR_DEBUG0 == 1
1121 for(i=indexWas;i<points;i++)
1122 {
1123 if(ptdet->pDebug0)ptdet->pDebug0[i]=lasttv0;
1124 if(ptdet->pDebug1)ptdet->pDebug1[i]=lasttv1;
1125 if(ptdet->pDebug2)ptdet->pDebug2[i]=lasttv2;
1126 }
1127 #endif
1128 }
1129
1130 //TRACEX((" ctcss_detect() thit %i\n",thit));
1131
1132 if(pmrChan->rxCtcss->BlankingTimer>0)pmrChan->rxCtcss->BlankingTimer-=points;
1133 if(pmrChan->rxCtcss->BlankingTimer<0)pmrChan->rxCtcss->BlankingTimer=0;
1134
1135 if(thit>=0 && pmrChan->rxCtcss->decode<0 && !pmrChan->rxCtcss->BlankingTimer)
1136 {
1137 pmrChan->rxCtcss->decode=thit;
1138 }
1139 else if(thit<0 && pmrChan->rxCtcss->decode>=0)
1140 {
1141 pmrChan->rxCtcss->BlankingTimer=SAMPLE_RATE_NETWORK/5;
1142 pmrChan->rxCtcss->decode=-1;
1143
1144 for(tnum=0;tnum<CTCSS_NUM_CODES;tnum++)
1145 {
1146 t_tdet *ptdet=NULL;
1147 ptdet=&(pmrChan->rxCtcss->tdet[tnum]);
1148 ptdet->decode=0;
1149 ptdet->z[0]=ptdet->z[1]=ptdet->z[2]=ptdet->z[3]=0;
1150 }
1151 }
1152 //TRACEX((" ctcss_detect() thit %i %i\n",thit,pmrChan->rxCtcss->decode));
1153 return(0);
1154 }
1155 /*
1156 TxTestTone
1157 */
1158 static i16 TxTestTone(t_pmr_chan *pChan, i16 function)
1159 {
1160 if(function==1)
1161 {
1162 pChan->spsSigGen1->enabled=1;
1163 pChan->spsSigGen1->option=1;
1164 pChan->spsTx->source=pChan->spsSigGen1->sink;
1165 }
1166 else
1167 {
1168 pChan->spsSigGen1->option=3;
1169 }
1170 return 0;
1171 }
1172 /*
1173 assumes:
1174 sampling rate is 48KS/s
1175 samples are all 16 bits
1176 samples are filtered and decimated by 1/6th
1177 */
1178 t_pmr_chan *createPmrChannel(t_pmr_chan *tChan, i16 numSamples)
1179 {
1180 i16 i, *inputTmp;
1181
1182 t_pmr_chan *pChan;
1183 t_pmr_sps *pSps;
1184 t_dec_ctcss *pDecCtcss;
1185 t_tdet *ptdet;
1186
1187 TRACEX(("createPmrChannel(%p,%i)\n",tChan,numSamples));
1188
1189 pChan = (t_pmr_chan *)calloc(sizeof(t_pmr_chan),1);
1190
1191 if(pChan==NULL)
1192 {
1193 printf("createPmrChannel() failed\n");
1194 return(NULL);
1195 }
1196
1197 pChan->nSamplesRx=numSamples;
1198 pChan->nSamplesTx=numSamples;
1199
1200 pChan->index=pmrChanIndex++;
1201
1202 for(i=0;i<CTCSS_NUM_CODES;i++)
1203 {
1204 pChan->rxCtcssMap[i]=-1;
1205 }
1206
1207 pChan->rxCtcssIndex=-1;
1208
1209 if(tChan==NULL)
1210 {
1211 pChan->rxNoiseSquelchEnable=0;
1212 pChan->rxHpfEnable=0;
1213 pChan->rxDeEmpEnable=0;
1214 pChan->rxCenterSlicerEnable=0;
1215 pChan->rxCtcssDecodeEnable=0;
1216 pChan->rxDcsDecodeEnable=0;
1217
1218 pChan->rxCarrierPoint = 17000;
1219 pChan->rxCarrierHyst = 2500;
1220
1221 pChan->rxCtcssFreq=103.5;
1222
1223 pChan->txHpfEnable=0;
1224 pChan->txLimiterEnable=0;
1225 pChan->txPreEmpEnable=0;
1226 pChan->txLpfEnable=1;
1227 pChan->txCtcssFreq=103.5;
1228 pChan->txMixA=TX_OUT_VOICE;
1229 pChan->txMixB=TX_OUT_LSD;
1230 }
1231 else
1232 {
1233 pChan->rxDemod=tChan->rxDemod;
1234 pChan->rxCdType=tChan->rxCdType;
1235 pChan->rxSquelchPoint = tChan->rxSquelchPoint;
1236 pChan->rxCarrierHyst = 3000;
1237 pChan->rxCtcssFreq=tChan->rxCtcssFreq;
1238
1239 for(i=0;i<CTCSS_NUM_CODES;i++)
1240 pChan->rxCtcssMap[i]=tChan->rxCtcssMap[i];
1241
1242 pChan->txMod=tChan->txMod;
1243 pChan->txHpfEnable=1;
1244 pChan->txLpfEnable=1;
1245 pChan->txCtcssFreq=tChan->txCtcssFreq;
1246 pChan->txMixA=tChan->txMixA;
1247 pChan->txMixB=tChan->txMixB;
1248 pChan->radioDuplex=tChan->radioDuplex;
1249 }
1250
1251 TRACEX(("misc settings \n"));
1252
1253 if(pChan->rxCdType==CD_XPMR_NOISE){
1254 pChan->rxNoiseSquelchEnable=1;
1255 }
1256
1257 if(pChan->rxDemod==RX_AUDIO_FLAT){
1258 pChan->rxHpfEnable=1;
1259 pChan->rxDeEmpEnable=1;
1260 }
1261
1262 pChan->rxCarrierPoint=(pChan->rxSquelchPoint*32767)/100;
1263 pChan->rxCarrierHyst = 3000; //pChan->rxCarrierPoint/15;
1264
1265 pChan->rxDcsDecodeEnable=0;
1266
1267 if(pChan->rxCtcssFreq!=0){
1268 pChan->rxHpfEnable=1;
1269 pChan->rxCenterSlicerEnable=1;
1270 pChan->rxCtcssDecodeEnable=1;
1271 pChan->rxCtcssIndex=CtcssFreqIndex(pChan->rxCtcssFreq);
1272 }
1273
1274 if(pChan->txMod){
1275 pChan->txPreEmpEnable=1;
1276 pChan->txLimiterEnable=1;
1277 }
1278
1279 TRACEX(("calloc buffers \n"));
1280
1281 pChan->pRxDemod = calloc(numSamples,2);
1282 pChan->pRxNoise = calloc(numSamples,2);
1283 pChan->pRxBase = calloc(numSamples,2);
1284 pChan->pRxHpf = calloc(numSamples,2);
1285 pChan->pRxLsd = calloc(numSamples,2);
1286 pChan->pRxSpeaker = calloc(numSamples,2);
1287 pChan->pRxCtcss = calloc(numSamples,2);
1288 pChan->pRxDcTrack = calloc(numSamples,2);
1289 pChan->pRxLsdLimit = calloc(numSamples,2);
1290
1291
1292 pChan->pTxBase = calloc(numSamples,2);
1293 pChan->pTxHpf = calloc(numSamples,2);
1294 pChan->pTxPreEmp = calloc(numSamples,2);
1295 pChan->pTxLimiter = calloc(numSamples,2);
1296 pChan->pTxLsd = calloc(numSamples,2);
1297 pChan->pTxLsdLpf = calloc(numSamples,2);
1298 pChan->pTxComposite = calloc(numSamples,2);
1299 pChan->pSigGen0 = calloc(numSamples,2);
1300 pChan->pSigGen1 = calloc(numSamples,2);
1301
1302 pChan->pTxCode = calloc(numSamples,2);
1303 pChan->pTxOut = calloc(numSamples,2*2*6); // output buffer
1304
1305 #if XPMR_DEBUG0 == 1
1306 pChan->pTxPttIn = calloc(numSamples,2);
1307 pChan->pTxPttOut = calloc(numSamples,2);
1308 pChan->prxDebug0 = calloc(numSamples,2);
1309 pChan->prxDebug1 = calloc(numSamples,2);
1310 pChan->prxDebug2 = calloc(numSamples,2);
1311 pChan->prxDebug3 = calloc(numSamples,2);
1312 pChan->ptxDebug0 = calloc(numSamples,2);
1313 pChan->ptxDebug1 = calloc(numSamples,2);
1314 pChan->ptxDebug2 = calloc(numSamples,2);
1315 pChan->ptxDebug3 = calloc(numSamples,2);
1316 pChan->pNull = calloc(numSamples,2);
1317 for(i=0;i<numSamples;i++)pChan->pNull[i]=((i%(numSamples/2))*8000)-4000;
1318 #endif
1319
1320 TRACEX(("create ctcss\n"));
1321
1322 pDecCtcss = (t_dec_ctcss *)calloc(sizeof(t_dec_ctcss),1);
1323
1324 pChan->rxCtcss=pDecCtcss;
1325 pDecCtcss->enabled=1;
1326 pDecCtcss->gain=1*M_Q8;
1327 pDecCtcss->limit=8192;
1328 pDecCtcss->input=pChan->pRxLsdLimit;
1329 pDecCtcss->testIndex=pChan->rxCtcssIndex;
1330 if(!pDecCtcss->testIndex)pDecCtcss->testIndex=1;
1331 pChan->rxCtcssMap[pChan->rxCtcssIndex]=pChan->rxCtcssIndex;
1332 pDecCtcss->decode=-1;
1333
1334 for(i=0;i<CTCSS_NUM_CODES;i++)
1335 {
1336 ptdet=&(pChan->rxCtcss->tdet[i]);
1337 ptdet->state=1;
1338 ptdet->setpt=(M_Q15*0.067); // 0.069
1339 ptdet->hyst =(M_Q15*0.020);
1340 ptdet->counterFactor=coef_ctcss_div[i];
1341 ptdet->binFactor=(M_Q15*0.135); // was 0.140
1342 ptdet->fudgeFactor=8;
1343 }
1344
1345 // General Purpose Function Generator
1346 pSps=pChan->spsSigGen1=createPmrSps();
1347 pSps->parentChan=pChan;
1348 pSps->sink=pChan->pSigGen1;
1349 pSps->numChanOut=1;
1350 pSps->selChanOut=0;
1351 pSps->sigProc=SigGen;
1352 pSps->nSamples=pChan->nSamplesTx;
1353 pSps->sampleRate=SAMPLE_RATE_NETWORK;
1354 pSps->freq=10000; // in increments of 0.1 Hz
1355 pSps->outputGain=(.25*M_Q8);
1356 pSps->option=0;
1357 pSps->interpolate=1;
1358 pSps->decimate=1;
1359 pSps->enabled=0;
1360
1361
1362 // CTCSS ENCODER
1363 pSps = pChan->spsSigGen0 = createPmrSps();
1364 pSps->parentChan=pChan;
1365 pSps->sink=pChan->pTxLsd;
1366 pSps->sigProc=SigGen;
1367 pSps->numChanOut=1;
1368 pSps->selChanOut=0;
1369 pSps->nSamples=pChan->nSamplesTx;
1370 pSps->sampleRate=SAMPLE_RATE_NETWORK;
1371 pSps->freq=pChan->txCtcssFreq*10; // in increments of 0.1 Hz
1372 pSps->outputGain=(0.5*M_Q8);
1373 pSps->option=0;
1374 pSps->interpolate=1;
1375 pSps->decimate=1;
1376 pSps->enabled=0;
1377
1378
1379 // Tx LSD Low Pass Filter
1380 pSps=pChan->spsTxLsdLpf=pSps->nextSps=createPmrSps();
1381 pSps->source=pChan->pTxLsd;
1382 pSps->sink=pChan->pTxLsdLpf;
1383 pSps->sigProc=pmr_gp_fir;
1384 pSps->enabled=0;
1385 pSps->numChanOut=1;
1386 pSps->selChanOut=0;
1387 pSps->nSamples=pChan->nSamplesTx;
1388 pSps->decimator=pSps->decimate=1;
1389 pSps->interpolate=1;
1390 pSps->inputGain=(1*M_Q8);
1391 pSps->outputGain=(1*M_Q8);
1392
1393 if(pChan->txCtcssFreq>203.0)
1394 {
1395 pSps->ncoef=taps_fir_lpf_250_9_66;
1396 pSps->size_coef=2;
1397 pSps->coef=(void*)coef_fir_lpf_250_9_66;
1398 pSps->nx=taps_fir_lpf_250_9_66;
1399 pSps->size_x=2;
1400 pSps->x=(void*)(calloc(pSps->nx,pSps->size_x));
1401 pSps->calcAdjust=gain_fir_lpf_250_9_66;
1402 }
1403 else
1404 {
1405 pSps->ncoef=taps_fir_lpf_215_9_88;
1406 pSps->size_coef=2;
1407 pSps->coef=(void*)coef_fir_lpf_215_9_88;
1408 pSps->nx=taps_fir_lpf_215_9_88;
1409 pSps->size_x=2;
1410 pSps->x=(void*)(calloc(pSps->nx,pSps->size_x));
1411 pSps->calcAdjust=gain_fir_lpf_215_9_88;
1412 }
1413
1414 pSps->inputGain=(1*M_Q8);
1415 pSps->outputGain=(1*M_Q8);
1416
1417 if(pSps==NULL)printf("Error: calloc(), createPmrChannel()\n");
1418
1419
1420 // RX Process
1421 TRACEX(("create rx\n"));
1422 pSps = NULL;
1423
1424 // allocate space for first sps and set pointers
1425 pSps=pChan->spsRx=createPmrSps();
1426 pSps->parentChan=pChan;
1427 pSps->source=NULL; //set when called
1428 pSps->sink=pChan->pRxBase;
1429 pSps->sigProc=pmr_rx_frontend;
1430 pSps->enabled=1;
1431 pSps->decimator=pSps->decimate=6;
1432 pSps->interpolate=pSps->interpolate=1;
1433 pSps->nSamples=pChan->nSamplesRx;
1434 pSps->ncoef=taps_fir_bpf_noise_1;
1435 pSps->size_coef=2;
1436 pSps->coef=(void*)coef_fir_lpf_3K_1;
1437 pSps->coef2=(void*)coef_fir_bpf_noise_1;
1438 pSps->nx=taps_fir_bpf_noise_1;
1439 pSps->size_x=2;
1440 pSps->x=(void*)(calloc(pSps->nx,pSps->size_coef));
1441 pSps->calcAdjust=(gain_fir_lpf_3K_1*256)/0x0100;
1442 pSps->outputGain=(1.0*M_Q8);
1443 pSps->discfactor=2;
1444 pSps->hyst=pChan->rxCarrierHyst;
1445 pSps->setpt=pChan->rxCarrierPoint;
1446 pChan->prxSquelchAdjust=&pSps->setpt;
1447 #if XPMR_DEBUG0 == 1
1448 pSps->debugBuff0=pChan->pRxDemod;
1449 pSps->debugBuff1=pChan->pRxNoise;
1450 pSps->debugBuff2=pChan->prxDebug0;
1451 #endif
1452
1453
1454 // allocate space for next sps and set pointers
1455 // Rx SubAudible Decoder Low Pass Filter
1456 pSps=pSps->nextSps=createPmrSps();
1457 pSps->parentChan=pChan;
1458 pSps->source=pChan->pRxBase;
1459 pSps->sink=pChan->pRxLsd;
1460 pSps->sigProc=pmr_gp_fir;
1461 pSps->enabled=1;
1462 pSps->numChanOut=1;
1463 pSps->selChanOut=0;
1464 pSps->nSamples=pChan->nSamplesRx;
1465 pSps->decimator=pSps->decimate=1;
1466 pSps->interpolate=1;
1467
1468 if(pChan->rxCtcssFreq>203.5)
1469 {
1470 pSps->ncoef=taps_fir_lpf_250_9_66;
1471 pSps->size_coef=2;
1472 pSps->coef=(void*)coef_fir_lpf_250_9_66;
1473 pSps->nx=taps_fir_lpf_250_9_66;
1474 pSps->size_x=2;
1475 pSps->x=(void*)(calloc(pSps->nx,pSps->size_x));
1476 pSps->calcAdjust=gain_fir_lpf_250_9_66;
1477 }
1478 else
1479 {
1480 pSps->ncoef=taps_fir_lpf_215_9_88;
1481 pSps->size_coef=2;
1482 pSps->coef=(void*)coef_fir_lpf_215_9_88;
1483 pSps->nx=taps_fir_lpf_215_9_88;
1484 pSps->size_x=2;
1485 pSps->x=(void*)(calloc(pSps->nx,pSps->size_x));
1486 pSps->calcAdjust=gain_fir_lpf_215_9_88;
1487 }
1488
1489 pSps->inputGain=(1*M_Q8);
1490 pSps->outputGain=(1*M_Q8);
1491 pChan->prxCtcssMeasure=pSps->sink;
1492 pChan->prxCtcssAdjust=&(pSps->outputGain);
1493
1494
1495 // allocate space for next sps and set pointers
1496 // CenterSlicer
1497 if(pChan->rxCenterSlicerEnable)
1498 {
1499 pSps=pSps->nextSps=createPmrSps();
1500 pSps->parentChan=pChan;
1501 pSps->source=pChan->pRxLsd;
1502 pSps->sink=pChan->pRxDcTrack;
1503 pSps->buff=pChan->pRxLsdLimit;
1504 pSps->sigProc=CenterSlicer;
1505 pSps->enabled=1;
1506 pSps->nSamples=pChan->nSamplesRx;
1507 pSps->discfactor=800;
1508 pSps->inputGain=(1*M_Q8);
1509 pSps->outputGain=(1*M_Q8);
1510 pSps->setpt=3000;
1511 pSps->inputGainB=1000; // limiter set point
1512 }
1513
1514 // allocate space for next sps and set pointers
1515 // Rx HPF
1516 pSps=pSps->nextSps=createPmrSps();
1517 pSps->parentChan=pChan;
1518 pChan->spsRxHpf=pSps;
1519 pSps->source=pChan->pRxBase;
1520 pSps->sink=pChan->pRxHpf;
1521 pSps->sigProc=pmr_gp_fir;
1522 pSps->enabled=1;
1523 pSps->numChanOut=1;
1524 pSps->selChanOut=0;
1525 pSps->nSamples=pChan->nSamplesRx;
1526 pSps->decimator=pSps->decimate=1;
1527 pSps->interpolate=1;
1528 pSps->ncoef=taps_fir_hpf_300_9_66;
1529 pSps->size_coef=2;
1530 pSps->coef=(void*)coef_fir_hpf_300_9_66;
1531 pSps->nx=taps_fir_hpf_300_9_66;
1532 pSps->size_x=2;
1533 pSps->x=(void*)(calloc(pSps->nx,pSps->size_x));
1534 if(pSps==NULL)printf("Error: calloc(), createPmrChannel()\n");
1535 pSps->calcAdjust=gain_fir_hpf_300_9_66;
1536 pSps->inputGain=(1*M_Q8);
1537 pSps->outputGain=(1*M_Q8);
1538 pChan->spsRxOut=pSps;
1539
1540 // allocate space for next sps and set pointers
1541 // Rx DeEmp
1542 if(pChan->rxDeEmpEnable){
1543 pSps=pSps->nextSps=createPmrSps();
1544 pSps->parentChan=pChan;
1545 pChan->spsRxDeEmp=pSps;
1546 pSps->source=pChan->pRxHpf;
1547 pSps->sink=pChan->pRxSpeaker;
1548 pChan->spsRxOut=pSps; // OUTPUT STRUCTURE! maw
1549 pSps->sigProc=gp_inte_00;
1550 pSps->enabled=1;
1551 pSps->nSamples=pChan->nSamplesRx;
1552
1553 pSps->ncoef=taps_int_lpf_300_1_2;
1554 pSps->size_coef=2;
1555 pSps->coef=(void*)coef_int_lpf_300_1_2;
1556
1557 pSps->nx=taps_int_lpf_300_1_2;
1558 pSps->size_x=4;
1559 pSps->x=(void*)(calloc(pSps->nx,pSps->size_x));
1560 if(pSps==NULL)printf("Error: calloc(), createPmrChannel()\n");
1561 pSps->calcAdjust=gain_int_lpf_300_1_2/2;
1562 pSps->inputGain=(1.0*M_Q8);
1563 pSps->outputGain=(1.0*M_Q8);
1564 pChan->prxVoiceMeasure=pSps->sink;
1565 pChan->prxVoiceAdjust=&(pSps->outputGain);
1566 }
1567
1568 if(pChan->rxDelayLineEnable)
1569 {
1570 TRACEX(("create delayline\n"));
1571 pSps=pChan->spsDelayLine=pSps->nextSps=createPmrSps();
1572 pSps->sigProc=DelayLine;
1573 pSps->source=pChan->pRxSpeaker;
1574 pSps->sink=pChan->pRxSpeaker;
1575 pSps->enabled=0;
1576 pSps->inputGain=1*M_Q8;
1577 pSps->outputGain=1*M_Q8;
1578 pSps->nSamples=pChan->nSamplesRx;
1579 pSps->buffSize=4096;
1580 pSps->buff=calloc(4096,2); // one second maximum
1581 pSps->buffLead = (SAMPLE_RATE_NETWORK*0.100);
1582 pSps->buffOutIndex=0;
1583 }
1584
1585 if(pChan->rxCdType==CD_XPMR_VOX)
1586 {
1587 TRACEX(("create vox measureblock\n"));
1588 pSps=pChan->spsRxVox=pSps->nextSps=createPmrSps();
1589 pSps->sigProc=MeasureBlock;
1590 pSps->parentChan=pChan;
1591 pSps->source=pChan->pRxBase;
1592 pSps->sink=pChan->prxDebug1;
1593 pSps->inputGain=1*M_Q8;
1594 pSps->outputGain=1*M_Q8;
1595 pSps->nSamples=pChan->nSamplesRx;
1596 pSps->discfactor=3;
1597 pSps->setpt=(0.01*M_Q15);
1598 pSps->hyst=(pSps->setpt/10);
1599 pSps->enabled=1;
1600 }
1601
1602 // tuning measure block
1603 pSps=pChan->spsMeasure=pSps->nextSps=createPmrSps();
1604 pSps->parentChan=pChan;
1605 pSps->source=pChan->spsRx->sink;
1606 pSps->sink=pChan->prxDebug2;
1607 pSps->sigProc=MeasureBlock;
1608 pSps->enabled=0;
1609 pSps->nSamples=pChan->nSamplesRx;
1610 pSps->discfactor=10;
1611
1612 pSps->nextSps=NULL; // last sps in chain RX
1613
1614
1615 // CREATE TRANSMIT CHAIN
1616 TRACEX((" create tx\n"));
1617 inputTmp=NULL;
1618 pSps = NULL;
1619
1620 // allocate space for first sps and set pointers
1621
1622 // Tx HPF SubAudible
1623 if(pChan->txHpfEnable)
1624 {
1625 pSps=createPmrSps();
1626 pChan->spsTx=pSps;
1627 pSps->source=pChan->pTxBase;
1628 pSps->sink=pChan->pTxHpf;
1629 pSps->sigProc=pmr_gp_fir;
1630 pSps->enabled=1;
1631 pSps->numChanOut=1;
1632 pSps->selChanOut=0;
1633 pSps->nSamples=pChan->nSamplesTx;
1634 pSps->decimator=pSps->decimate=1;
1635 pSps->interpolate=1;
1636 pSps->ncoef=taps_fir_hpf_300_9_66;
1637 pSps->size_coef=2;
1638 pSps->coef=(void*)coef_fir_hpf_300_9_66;
1639 pSps->nx=taps_fir_hpf_300_9_66;
1640 pSps->size_x=2;
1641 pSps->x=(void*)(calloc(pSps->nx,pSps->size_x));
1642 if(pSps==NULL)printf("Error: calloc(), createPmrChannel()\n");
1643 pSps->calcAdjust=gain_fir_hpf_300_9_66;
1644 pSps->inputGain=(1*M_Q8);
1645 pSps->outputGain=(1*M_Q8);
1646 inputTmp=pChan->pTxHpf;
1647 }
1648
1649 // Tx PreEmphasis
1650 if(pChan->txPreEmpEnable)
1651 {
1652 if(pSps==NULL) pSps=pChan->spsTx=createPmrSps();
1653 else pSps=pSps->nextSps=createPmrSps();
1654
1655 pSps->parentChan=pChan;
1656 pSps->source=inputTmp;
1657 pSps->sink=pChan->pTxPreEmp;
1658
1659 pSps->sigProc=gp_diff;
1660 pSps->enabled=1;
1661 pSps->nSamples=pChan->nSamplesTx;
1662
1663 pSps->ncoef=taps_int_hpf_4000_1_2;
1664 pSps->size_coef=2;
1665 pSps->coef=(void*)coef_int_hpf_4000_1_2;
1666
1667 pSps->nx=taps_int_hpf_4000_1_2;
1668 pSps->size_x=2;
1669 pSps->x=(void*)(calloc(pSps->nx,pSps->size_x));
1670 if(pSps==NULL)printf("Error: calloc(), createPmrChannel()\n");
1671 pSps->outputGain=(1*M_Q8);
1672 pSps->calcAdjust=gain_int_hpf_4000_1_2;
1673 pSps->inputGain=(1*M_Q8);
1674 pSps->outputGain=(1*M_Q8);
1675 inputTmp=pSps->sink;
1676 }
1677
1678 // Tx Limiter
1679 if(pChan->txLimiterEnable)
1680 {
1681 if(pSps==NULL) pSps=pChan->spsTx=createPmrSps();
1682 else pSps=pSps->nextSps=createPmrSps();
1683 pSps->source=inputTmp;
1684 pSps->sink=pChan->pTxLimiter;
1685 pSps->sigProc=SoftLimiter;
1686 pSps->enabled=1;
1687 pSps->nSamples=pChan->nSamplesTx;
1688 pSps->inputGain=(1*M_Q8);
1689 pSps->outputGain=(1*M_Q8);
1690 pSps->setpt=12000;
1691 inputTmp=pSps->sink;
1692 }
1693
1694 // Composite Mix of Voice and LSD
1695 if((pChan->txMixA==TX_OUT_COMPOSITE)||(pChan->txMixB==TX_OUT_COMPOSITE))
1696 {
1697 if(pSps==NULL)
1698 pSps=pChan->spsTx=createPmrSps();
1699 else
1700 pSps=pSps->nextSps=createPmrSps();
1701 pSps->source=inputTmp;
1702 pSps->sourceB=pChan->pTxLsdLpf; //asdf ??? !!! maw pTxLsdLpf
1703 pSps->sink=pChan->pTxComposite;
1704 pSps->sigProc=pmrMixer;
1705 pSps->enabled=1;
1706 pSps->nSamples=pChan->nSamplesTx;
1707 pSps->inputGain=2*M_Q8;
1708 pSps->inputGainB=1*M_Q8/8;
1709 pSps->outputGain=1*M_Q8;
1710 pSps->setpt=0;
1711 inputTmp=pSps->sink;
1712 pChan->ptxCtcssAdjust=&pSps->inputGainB;
1713 }
1714
1715 // Chan A Upsampler and Filter
1716 if(pSps==NULL) pSps=pChan->spsTx=createPmrSps();
1717 else pSps=pSps->nextSps=createPmrSps();
1718
1719 pChan->spsTxOutA=pSps;
1720 if(!pChan->spsTx)pChan->spsTx=pSps;
1721 pSps->parentChan=pChan;
1722
1723 if(pChan->txMixA==TX_OUT_COMPOSITE)
1724 {
1725 pSps->source=pChan->pTxComposite;
1726 }
1727 else if(pChan->txMixA==TX_OUT_LSD)
1728 {
1729 pSps->source=pChan->pTxLsdLpf;
1730 }
1731 else if(pChan->txMixA==TX_OUT_VOICE)
1732 {
1733 pSps->source=pChan->pTxHpf;
1734 }
1735 else if (pChan->txMixA==TX_OUT_AUX)
1736 {
1737 pSps->source=inputTmp;
1738 }
1739 else
1740 {
1741 pSps->source=NULL;
1742 }
1743
1744 pSps->sink=pChan->pTxOut;
1745 pSps->sigProc=pmr_gp_fir;
1746 pSps->enabled=1;
1747 pSps->numChanOut=2;
1748 pSps->selChanOut=0;
1749 pSps->nSamples=pChan->nSamplesTx;
1750 pSps->interpolate=6;
1751 pSps->ncoef=taps_fir_lpf_3K_1;
1752 pSps->size_coef=2;
1753 pSps->coef=(void*)coef_fir_lpf_3K_1;
1754 pSps->nx=taps_fir_lpf_3K_1;
1755 pSps->size_x=2;
1756 pSps->x=(void*)(calloc(pSps->nx,pSps->size_x));
1757 if(pSps==NULL)printf("Error: calloc(), createPmrChannel()\n");
1758 pSps->calcAdjust=gain_fir_lpf_3K_1;
1759 pSps->inputGain=(1*M_Q8);
1760 pSps->outputGain=(1*M_Q8);
1761 if(pChan->txMixA==pChan->txMixB)pSps->monoOut=1;
1762 else pSps->monoOut=0;
1763
1764
1765 // Chan B Upsampler and Filter
1766 if((pChan->txMixA!=pChan->txMixB)&&(pChan->txMixB!=TX_OUT_OFF))
1767 {
1768 if(pSps==NULL) pSps=pChan->spsTx=createPmrSps();
1769 else pSps=pSps->nextSps=createPmrSps();
1770
1771 pChan->spsTxOutB=pSps;
1772 pSps->parentChan=pChan;
1773 if(pChan->txMixB==TX_OUT_COMPOSITE)
1774 {
1775 pSps->source=pChan->pTxComposite;
1776 }
1777 else if(pChan->txMixB==TX_OUT_LSD)
1778 {
1779 pSps->source=pChan->pTxLsdLpf;
1780 // pChan->ptxCtcssAdjust=&pSps->inputGain;
1781 }
1782 else if(pChan->txMixB==TX_OUT_VOICE)
1783 {
1784 pSps->source=inputTmp;
1785 }
1786 else if(pChan->txMixB==TX_OUT_AUX)
1787 {
1788 pSps->source=pChan->pTxHpf;
1789 }
1790 else
1791 {
1792 pSps->source=NULL;
1793 }
1794
1795 pSps->sink=pChan->pTxOut;
1796 pSps->sigProc=pmr_gp_fir;
1797 pSps->enabled=1;
1798 pSps->numChanOut=2;
1799 pSps->selChanOut=1;
1800 pSps->mixOut=0;
1801 pSps->nSamples=pChan->nSamplesTx;
1802 pSps->interpolate=6;
1803 pSps->ncoef=taps_fir_lpf_3K_1;
1804 pSps->size_coef=2;
1805 pSps->coef=(void*)coef_fir_lpf_3K_1;
1806 pSps->nx=taps_fir_lpf_3K_1;
1807 pSps->size_x=2;
1808 pSps->x=(void*)(calloc(pSps->nx,pSps->size_x));
1809 if(pSps==NULL)printf("Error: calloc(), createPmrChannel()\n");
1810 pSps->calcAdjust=(gain_fir_lpf_3K_1);
1811 pSps->inputGain=(1*M_Q8);
1812 pSps->outputGain=(1*M_Q8);
1813
1814 }
1815
1816 pSps->nextSps=NULL;
1817
1818 #if XPMR_DEBUG0 == 1
1819 {
1820 t_tdet *ptdet;
1821 TRACEX((" configure tracing\n"));
1822
1823 pChan->rxCtcss->pDebug0=calloc(numSamples,2);
1824 pChan->rxCtcss->pDebug1=calloc(numSamples,2);
1825 pChan->rxCtcss->pDebug2=calloc(numSamples,2);
1826
1827 for(i=0;i<CTCSS_NUM_CODES;i++){
1828 ptdet=&(pChan->rxCtcss->tdet[i]);
1829 ptdet->pDebug0=calloc(numSamples,2);
1830 ptdet->pDebug1=calloc(numSamples,2);
1831 ptdet->pDebug2=calloc(numSamples,2);
1832 }
1833
1834 // buffer, 2 bytes per sample, and 16 channels
1835 pChan->prxDebug=calloc(numSamples*16,2);
1836 pChan->ptxDebug=calloc(numSamples*16,2);
1837 }
1838 #endif
1839
1840 TRACEX((" createPmrChannel() end\n"));
1841
1842 return pChan;
1843 }
1844 /*
1845 */
1846 i16 destroyPmrChannel(t_pmr_chan *pChan)
1847 {
1848 t_pmr_sps *pmr_sps, *tmp_sps;
1849 i16 i;
1850
1851 TRACEX(("destroyPmrChannel()\n"));
1852
1853 free(pChan->pRxDemod);
1854 free(pChan->pRxNoise);
1855 free(pChan->pRxBase);
1856 free(pChan->pRxHpf);
1857 free(pChan->pRxLsd);
1858 free(pChan->pRxSpeaker);
1859 free(pChan->pRxDcTrack);
1860 if(pChan->pRxLsdLimit)free(pChan->pRxLsdLimit);
1861 free(pChan->pTxBase);
1862 free(pChan->pTxHpf);
1863 free(pChan->pTxPreEmp);
1864 free(pChan->pTxLimiter);
1865 free(pChan->pTxLsd);
1866 free(pChan->pTxLsdLpf);
1867 if(pChan->pTxComposite)free(pChan->pTxComposite);
1868 free(pChan->pTxCode);
1869 free(pChan->pTxOut);
1870
1871 if(pChan->pSigGen0)free(pChan->pSigGen0);
1872 if(pChan->pSigGen1)free(pChan->pSigGen1);
1873
1874 #if XPMR_DEBUG0 == 1
1875 free(pChan->pTxPttIn);
1876 free(pChan->pTxPttOut);
1877 if(pChan->prxDebug)free(pChan->prxDebug);
1878 if(pChan->ptxDebug)free(pChan->ptxDebug);
1879 free(pChan->rxCtcss->pDebug0);
1880 free(pChan->rxCtcss->pDebug1);
1881
1882 free(pChan->prxDebug0);
1883 free(pChan->prxDebug1);
1884 free(pChan->prxDebug2);
1885 free(pChan->prxDebug3);
1886
1887 free(pChan->ptxDebug0);
1888 free(pChan->ptxDebug1);
1889 free(pChan->ptxDebug2);
1890 free(pChan->ptxDebug3);
1891
1892 for(i=0;i<CTCSS_NUM_CODES;i++)
1893 {
1894 free(pChan->rxCtcss->tdet[i].pDebug0);
1895 free(pChan->rxCtcss->tdet[i].pDebug1);
1896 free(pChan->rxCtcss->tdet[i].pDebug2);
1897 }
1898 #endif
1899
1900 free(pChan->pRxCtcss);
1901
1902 pmr_sps=pChan->spsRx;
1903
1904 while(pmr_sps)
1905 {
1906 tmp_sps = pmr_sps;
1907 pmr_sps = tmp_sps->nextSps;
1908 destroyPmrSps(tmp_sps);
1909 }
1910
1911 free(pChan);
1912
1913 return 0;
1914 }
1915 /*
1916 */
1917 t_pmr_sps *createPmrSps(void)
1918 {
1919 t_pmr_sps *pSps;
1920
1921 TRACEX(("createPmrSps()\n"));
1922
1923 pSps = (t_pmr_sps *)calloc(sizeof(t_pmr_sps),1);
1924
1925 if(!pSps)printf("Error: createPmrSps()\n");
1926
1927 // pSps->x=calloc(pSps->nx,pSps->size_x);
1928
1929 return pSps;
1930 }
1931 /*
1932 */
1933 i16 destroyPmrSps(t_pmr_sps *pSps)
1934 {
1935 TRACEX(("destroyPmrSps(%i)\n",pSps->index));
1936
1937 if(pSps->x!=NULL)free(pSps->x);
1938 free(pSps);
1939 return 0;
1940 }
1941 /*
1942 PmrRx does the whole buffer
1943 */
1944 i16 PmrRx(t_pmr_chan *pChan, i16 *input, i16 *output)
1945 {
1946 int i,ii;
1947 t_pmr_sps *pmr_sps;
1948
1949 TRACEX(("PmrRx() %i\n",pChan->frameCountRx));
1950
1951 if(pChan==NULL){
1952 printf("PmrRx() pChan == NULL\n");
1953 return 1;
1954 }
1955
1956 pChan->frameCountRx++;
1957
1958 pmr_sps=pChan->spsRx; // first sps
1959 pmr_sps->source=input;
1960
1961 if(output!=NULL)pChan->spsRxOut->sink=output; //last sps
1962
1963 #if 0
1964 if(pChan->inputBlanking>0)
1965 {
1966 pChan->inputBlanking-=pChan->nSamplesRx;
1967 if(pChan->inputBlanking<0)pChan->inputBlanking=0;
1968 for(i=0;i<pChan->nSamplesRx*6;i++)
1969 input[i]=0;
1970 }
1971 #endif
1972
1973 // || (pChan->radioDuplex && (pChan->pttIn || pChan->pttOut)))
1974 if(pChan->rxCpuSaver && !pChan->rxCarrierDetect)
1975 {
1976 if(pChan->spsRxHpf)pChan->spsRxHpf->enabled=0;
1977 if(pChan->spsRxDeEmp)pChan->spsRxDeEmp->enabled=0;
1978 }
1979 else
1980 {
1981 if(pChan->spsRxHpf)pChan->spsRxHpf->enabled=1;
1982 if(pChan->spsRxDeEmp)pChan->spsRxDeEmp->enabled=1;
1983 }
1984
1985 i=0;
1986 while(pmr_sps!=NULL && pmr_sps!=0)
1987 {
1988 TRACEX(("PmrRx() sps %i\n",i++));
1989 pmr_sps->sigProc(pmr_sps);
1990 pmr_sps = (t_pmr_sps *)(pmr_sps->nextSps);
1991 //pmr_sps=NULL; // sph maw
1992 }
1993
1994 #define XPMR_VOX_HANGTIME 2000
1995
1996 if(pChan->rxCdType==CD_XPMR_VOX)
1997 {
1998 if(pChan->spsRxVox->compOut)
1999 {
2000 pChan->rxVoxTimer=XPMR_VOX_HANGTIME; //VOX HangTime in ms
2001 }
2002 if(pChan->rxVoxTimer>0)
2003 {
2004 pChan->rxVoxTimer-=MS_PER_FRAME;
2005 pChan->rxCarrierDetect=1;
2006 }
2007 else
2008 {
2009 pChan->rxVoxTimer=0;
2010 pChan->rxCarrierDetect=0;
2011 }
2012 }
2013 else
2014 {
2015 pChan->rxCarrierDetect=!pChan->spsRx->compOut;
2016 }
2017
2018 if( !pChan->rxCpuSaver || pChan->rxCarrierDetect
2019 || pChan->rxCtcss->decode!=-1) ctcss_detect(pChan);
2020
2021 #if XPMR_DEBUG0 == 1
2022 // TRACEX(("Write file.\n"));
2023 ii=0;
2024 if(pChan->b.rxCapture)
2025 {
2026 for(i=0;i<pChan->nSamplesRx;i++)
2027 {
2028 pChan->prxDebug[ii++]=input[i*2*6]; // input data
2029 pChan->prxDebug[ii++]=output[i]; // output data
2030 pChan->prxDebug[ii++]=pChan->rxCarrierDetect*M_Q14; // carrier detect
2031 if(pChan->rxCtcss)
2032 pChan->prxDebug[ii++]=pChan->rxCtcss->decode*M_Q15/CTCSS_NUM_CODES; // decoded ctcss
2033 else
2034 pChan->prxDebug[ii++]=0;
2035
2036 pChan->prxDebug[ii++]=pChan->pRxNoise[i]; // rssi
2037 pChan->prxDebug[ii++]=pChan->pRxBase[i]; // decimated, low pass filtered
2038 pChan->prxDebug[ii++]=pChan->pRxHpf[i]; // output to network
2039 pChan->prxDebug[ii++]=pChan->pRxSpeaker[i];
2040
2041 pChan->prxDebug[ii++]=pChan->pRxLsd[i]; // CTCSS Filtered
2042 pChan->prxDebug[ii++]=pChan->pRxDcTrack[i]; // DC Restoration
2043 pChan->prxDebug[ii++]=pChan->pRxLsdLimit[i]; // Amplitude Limited
2044
2045 //pChan->prxDebug[ii++]=pChan->rxCtcss->tdet[pChan->rxCtcss->testIndex+1].pDebug0[i]; // Upper Adjacent CTCSS Code
2046 pChan->prxDebug[ii++]=pChan->rxCtcss->tdet[pChan->rxCtcss->testIndex].pDebug0[i]; // Primary CTCSS Code
2047 pChan->prxDebug[ii++]=pChan->rxCtcss->tdet[pChan->rxCtcss->testIndex].pDebug1[i]; // dv/dt of decoder output
2048 pChan->prxDebug[ii++]=pChan->rxCtcss->tdet[pChan->rxCtcss->testIndex].pDebug2[i];
2049
2050 //pChan->prxDebug[ii++]=pChan->rxCtcss->tdet[pChan->rxCtcss->testIndex-1].pDebug0[i]; // Lower Adjacent CTCSS Code
2051
2052 pChan->prxDebug[ii++]=pChan->prxDebug1[i]; // Measure Output for VOX
2053 pChan->prxDebug[ii++]=pChan->prxDebug2[i]; // Measure Output for Tuning
2054 }
2055 }
2056 #endif
2057
2058 return 0;
2059 }
2060 /*
2061 PmrTx does the whole buffer
2062 */
2063 i16 PmrTx(t_pmr_chan *pChan, i16 *input, i16 *output)
2064 {
2065 int i, hit=0;
2066 t_pmr_sps *pmr_sps;
2067
2068 pChan->frameCountTx++;
2069
2070 TRACEX(("PmrTx() %i\n",pChan->frameCountTx));
2071
2072 if(pChan==NULL){
2073 printf("PmrTx() pChan == NULL\n");
2074 return 1;
2075 }
2076
2077 if(pChan->b.startSpecialTone)
2078 {
2079 pChan->b.startSpecialTone=0;
2080 pChan->spsSigGen1->option=1;
2081 pChan->spsSigGen1->enabled=1;
2082 pChan->b.doingSpecialTone=1;
2083 } else if(pChan->b.stopSpecialTone)
2084 {
2085 pChan->b.stopSpecialTone=0;
2086 pChan->spsSigGen1->option=0;
2087 pChan->b.doingSpecialTone=0;
2088 pChan->spsSigGen1->enabled=0;
2089 } else if(pChan->b.doingSpecialTone)
2090 {
2091 pChan->spsSigGen1->sink=output;
2092 pChan->spsSigGen1->sigProc(pChan->spsSigGen1);
2093 for(i=0;i<(pChan->nSamplesTx*2*6);i+=2)output[i+1]=output[i];
2094 return 0;
2095 }
2096
2097 // handle transmitter ptt input
2098 hit=0;
2099 if( pChan->txPttIn && pChan->txState==0)
2100 {
2101 pChan->txState = 2;
2102 pChan->txPttOut=1;
2103 pChan->spsSigGen0->freq=pChan->txCtcssFreq*10;
2104 pChan->spsSigGen0->option=1;
2105 pChan->spsSigGen0->enabled=1;
2106 if(pChan->spsTxOutA)pChan->spsTxOutA->enabled=1;
2107 if(pChan->spsTxOutB)pChan->spsTxOutB->enabled=1;
2108 if(pChan->spsTxLsdLpf)pChan->spsTxLsdLpf->enabled=1;
2109 TRACEX((" TxOn\n"));
2110 }
2111 else if(!pChan->txPttIn && pChan->txState==2)
2112 {
2113 if( pChan->txTocType==TOC_NONE || !pChan->txCtcssFreq )
2114 {
2115 hit=1;
2116 TRACEX((" Tx Off Immediate.\n"));
2117 }
2118 else if(pChan->txCtcssFreq && pChan->txTocType==TOC_NOTONE)
2119 {
2120 pChan->txState=3;
2121 pChan->txHangTime=TOC_NOTONE_TIME/MS_PER_FRAME;
2122 pChan->spsSigGen0->option=3;
2123 TRACEX((" Tx Turn Off No Tone Start.\n"));
2124 }
2125 else
2126 {
2127 pChan->txState=3;
2128 pChan->txHangTime=0;
2129 pChan->spsSigGen0->option=2;
2130 TRACEX((" Tx Turn Off Phase Shift Start.\n"));
2131 }
2132 }
2133 else if(pChan->txState==3)
2134 {
2135 if(pChan->txHangTime)
2136 {
2137 if(--pChan->txHangTime==0)hit=1;
2138
2139 }
2140 else if(pChan->txHangTime<=0 && pChan->spsSigGen0->state==0)
2141 {
2142 hit=1;
2143 TRACEX((" Tx Off TOC.\n"));
2144 }
2145 if(pChan->txPttIn)
2146 {
2147 TRACEX((" Tx Key During HangTime\n"));
2148 if((pChan->txTocType==TOC_PHASE)||(pChan->txTocType==TOC_NONE))
2149 {
2150 pChan->txState = 2;
2151 hit=0;
2152 }
2153 }
2154 }
2155
2156 if( pChan->txCpuSaver && !hit && !pChan->txPttIn && !pChan->txPttOut && pChan->txState==0 ) return (1);
2157
2158 if(hit)
2159 {
2160 pChan->txPttOut=0;
2161 pChan->txState=0;
2162 if(pChan->spsTxLsdLpf)pChan->spsTxLsdLpf->option=3;
2163 if(pChan->spsTxOutA)pChan->spsTxOutA->option=3;
2164 if(pChan->spsTxOutB)pChan->spsTxOutB->option=3;
2165 TRACEX((" Tx Off hit.\n"));
2166 }
2167
2168 if(pChan->spsSigGen0)
2169 {
2170 pChan->spsSigGen0->sigProc(pChan->spsSigGen0);
2171 pmr_sps=pChan->spsSigGen0->nextSps;
2172 i=0;
2173 while(pmr_sps!=NULL && pmr_sps!=0)
2174 {
2175 TRACEX((" PmrTx() subaudible sps %i\n",i++));
2176 //printf(" CTCSS ENCODE %i %i\n",pChan->spsSigGen0->freq,pChan->spsSigGen0->outputGain);
2177 pmr_sps->sigProc(pmr_sps);
2178 pmr_sps = (t_pmr_sps *)(pmr_sps->nextSps);
2179 }
2180 }
2181
2182 if(pChan->spsSigGen1 && pChan->spsSigGen1->enabled)
2183 {
2184 pChan->spsSigGen1->sigProc(pChan->spsSigGen1);
2185 }
2186
2187 // Do Voice
2188 pmr_sps=pChan->spsTx;
2189 if(!pChan->spsSigGen1->enabled)pmr_sps->source=input;
2190 else input=pmr_sps->source;
2191
2192 if(output!=NULL)
2193 {
2194 if(pChan->spsTxOutA)pChan->spsTxOutA->sink=output;
2195 if(pChan->spsTxOutB)pChan->spsTxOutB->sink=output;
2196 }
2197
2198 i=0;
2199 while(pmr_sps!=NULL && pmr_sps!=0)
2200 {
2201 TRACEX((" PmrTx() sps %i\n",i++));
2202 pmr_sps->sigProc(pmr_sps);
2203 pmr_sps = (t_pmr_sps *)(pmr_sps->nextSps);
2204 }
2205
2206
2207 if(pChan->txMixA==TX_OUT_OFF || !pChan->txPttOut){
2208 for(i=0;i<pChan->nSamplesTx*2*6;i+=2)output[i]=0;
2209 }
2210
2211 if(pChan->txMixB==TX_OUT_OFF || !pChan->txPttOut ){
2212 for(i=0;i<pChan->nSamplesTx*2*6;i+=2)output[i+1]=0;
2213 }
2214
2215 #if XPMR_DEBUG0 == 1
2216 if(pChan->b.txCapture)
2217 {
2218 i16 ii=0;
2219 for(i=0;i<pChan->nSamplesTx;i++)
2220 {
2221 pChan->ptxDebug[ii++]=input[i];
2222 pChan->ptxDebug[ii++]=output[i*2*6];
2223 pChan->ptxDebug[ii++]=output[(i*2*6)+1];
2224 pChan->ptxDebug[ii++]=pChan->txPttIn*8192;
2225
2226 pChan->ptxDebug[ii++]=pChan->txPttOut*8192;
2227 if(pChan->txHpfEnable)pChan->ptxDebug[ii++]=pChan->pTxHpf[i];
2228 else pChan->ptxDebug[ii++]=0;
2229 if(pChan->txPreEmpEnable)pChan->ptxDebug[ii++]=pChan->pTxPreEmp[i];
2230 else pChan->ptxDebug[ii++]=0;
2231 if(pChan->txLimiterEnable)pChan->ptxDebug[ii++]=pChan->pTxLimiter[i];
2232 else pChan->ptxDebug[ii++]=0;
2233
2234 pChan->ptxDebug[ii++]=pChan->pTxLsd[i];
2235 pChan->ptxDebug[ii++]=pChan->pTxLsdLpf[i];
2236 pChan->ptxDebug[ii++]=pChan->pTxComposite[i];
2237 pChan->ptxDebug[ii++]=pChan->pSigGen1[i];
2238
2239 #if 1
2240 pChan->ptxDebug[ii++]=pChan->ptxDebug0[i];
2241 pChan->ptxDebug[ii++]=pChan->ptxDebug1[i];
2242 pChan->ptxDebug[ii++]=pChan->ptxDebug2[i];
2243 pChan->ptxDebug[ii++]=pChan->ptxDebug3[i];
2244 #else
2245 pChan->ptxDebug[ii++]=0;
2246 pChan->ptxDebug[ii++]=0;
2247 pChan->ptxDebug[ii++]=0;
2248 pChan->ptxDebug[ii++]=0;
2249 #endif
2250 }
2251 }
2252 #endif
2253
2254 return 0;
2255 }
2256 /* end of file */
Open Source Private Branch Exchange (PBX)