demo.cpp

This R2.9 revision of the CLID detector provides the TYPE 1 (on-hook, between first and second ring,

/*-------------------------------------------------------------------------*/
void                    _add_config
/*-------------------------------------------------------------------------*/
(
)
{
    _AddTgCfg.Hi.sAmp = 0;
    _AddTgCfg.Hi.sFreq = 0;

    _AddTgCfg.Lo.sAmp = (S16)(_Gen.fRxLoLevel*pow(10.0, +18.0/20.)+0.5);
    _AddTgCfg.Lo.sFreq = (S16)((32768./4000.)*(2130.0+_Gen.iFreqCntr)); 

    _AddTgCfg.sPreSilenceDuration =  0;
    _AddTgCfg.sSignalDuration =      -1;
    _AddTgCfg.sPostSilenceDuration = 100;
    _AddTgCfg.sCmd = TG_CMD_TONE;

    TG_control(&_AddTgDb, &_AddTgCfg);
}

/*-------------------------------------------------------------------------*/
void                    tg_config
/*-------------------------------------------------------------------------*/
(
)
{
    if(_Gen.iFreqCntr >= (2*_Gen.iFreqSteps+1))
    {
        // var of hi
        _Gen.iLoIdx = 0;
        _Gen.iHiIdx = _Gen.iFreqCntr - (3*_Gen.iFreqSteps+1);
    }
    else
    {
        // var of lo
        _Gen.iLoIdx = _Gen.iFreqCntr - 1*_Gen.iFreqSteps;
        _Gen.iHiIdx = 0;
    }

    if (_Gen.iSame == _Gen.iSameMax)
    {
        _TgCfg.Hi.sAmp = 0;
        _TgCfg.Lo.sAmp = 0;
    }
    else
    {
        _TgCfg.Hi.sAmp = (S16)(_Gen.fRxHiLevel+0.5);
        _TgCfg.Lo.sAmp = (S16)(_Gen.fRxLoLevel+0.5);
    }

    _Gen.fLoDev = (_Gen.iLoIdx*_Gen.fFreqDev)/_Gen.iFreqSteps;
    _Gen.fHiDev = (_Gen.iHiIdx*_Gen.fFreqDev)/_Gen.iFreqSteps;

    _TgCfg.Lo.sFreq = (S16)((32768./4000.)*2130.0 * 
        (1.0 + _Gen.fLoDev));
    _TgCfg.Hi.sFreq = (S16)((32768./4000.)*2750.0 * 
        (1.0 + _Gen.fHiDev));

    _TgCfg.sPreSilenceDuration =  (S16) _Gen.iPreSilenceDuration/(STD_FR_SZ/8);
    _TgCfg.sSignalDuration =      (S16) _Gen.iSignalDuration/(STD_FR_SZ/8);
    _TgCfg.sPostSilenceDuration = (S16) _Gen.iPostSilenceDuration/(STD_FR_SZ/8);
    _TgCfg.sCmd = TG_CMD_TONE;

    TG_control(&_TgDb, &_TgCfg);

    if ((fabs(_Gen.fLoDev) < 0.007) && (fabs(_Gen.fHiDev)< 0.007))
    {
        _Control.iCatchCntr = 14;
    }
    else
    {
        _Control.iCatchCntr = -1;
    }
}
/*-------------------------------------------------------------------------*/
void                        gen_input_cas
/*-------------------------------------------------------------------------*/
(
S16 *pIn
)
{
    int k;
    static double afIn[ICLID_FR_SZ];

//  gen noise
    for(k=0; k < ICLID_FR_SZ; k++)afIn[k] = 0;
    add_noise(_Gen.iRxNoise, afIn);

//  clear frame for the current packet, current tone
    for(k=0; k < STD_FR_SZ; k++)pIn[k] = 0;

// add dtmf
    S16 sTgState = TG_process(&_TgDb, &_TgScratch, pIn);
#if (_CAS_MODE == 4)
    TG_process(&_AddTgDb, &_TgScratch, pIn);
#endif
// add noise
    for(k=0; k < STD_FR_SZ; k++)pIn[k] = pIn[k] + (S16)afIn[k];

    if (sTgState == 0)
    {
// next packet, the same tone.
        ++_Gen.iSame;
#if (_CAS_MODE == 0)
        if (_Gen.iSame == _Gen.iSameMax+1)
        {
            _Gen.iSame = 0;
        	dump_results();
            
            if (_Control.iSameStop)
                DEMO_StepMode = TRUE;
// next freq content within the same tone
            ++_Gen.iFreqCntr;
            if (_Gen.iFreqCntr >= 2*(2*_Gen.iFreqSteps+1))
            {
                _Gen.iFreqCntr = 0;
                DEMO_StepMode = TRUE;
            }

        }
        tg_config();
#else
        if (_Gen.iSame == _Gen.iSameMax+1)
        {
            _Gen.iSame = 0;
        	dump_results();
            
            if (_Control.iSameStop)
                DEMO_StepMode = TRUE;
            ++_Gen.iFreqCntr;
            if (_Gen.iFreqCntr >= 2*(2*_Gen.iFreqSteps+1))
            {
                _Gen.iFreqCntr = 0;
                if (_Control.iSeriaStop)
                    DEMO_StepMode = TRUE;
            }
#if (_CAS_MODE == 1)
            _Gen.iSignalDuration += (ICLID_FR_SZ/8);
#elif (_CAS_MODE == 2)
            _Gen.fRxHiLevel /= 1.12202;
#elif (_CAS_MODE == 3)
            _Gen.fRxLoLevel *= 1.12202;
            _Gen.fRxHiLevel *= 1.12202;
#elif (_CAS_MODE == 4)
#endif
        }
        _cas_config();
#if (_CAS_MODE == 4)
        _add_config();
#endif

#endif
    }
}

/*-------------------------------------------------------------------------*/
void                        gen_input_clid
/*-------------------------------------------------------------------------*/
(
S16 *pIn
)
{
    int k;
    static double afIn[ICLID_FR_SZ];

//  clear frame for the current packet
    for(k=0; k < ICLID_FR_SZ; k++)afIn[k] = 0;

    int iFinished  = _gen_clid(afIn);
    add_noise(_Gen.iRxNoise, afIn);

    for(k=0; k < ICLID_FR_SZ; k++)
    {
        pIn[k] = (S16)afIn[k];
    }

    if (iFinished)
    {
        ++_Gen.iSame;
        _init_gen_clid();
        if (_Control.iSameStop)
        {
            DEMO_StepMode = TRUE;
        }
        if (_Gen.iSame == _Gen.iSameMax+1)
        {
        	dump_results();
            if (_Control.iSeriaStop)
            {
                DEMO_StepMode = TRUE;
            }
        }
    }
}

/*-------------------------------------------------------------------------*/
void                        fill_input
/*-------------------------------------------------------------------------*/
(
S16 *pIn
)
{
	if(_Control.pInFile != NULL && _Frame > 0)
	{
        read_input(pIn);
	}
    else
    {
        switch(_Gen.sMode)
        {
        case 1:
        case 2:
            gen_input_clid(pIn);
            break;
        case 3:
            gen_input_cas(pIn);
        }
    }

    for (int k=0; k < ICLID_FR_SZ; k++)
    {
        double x = pIn[k]*4;
        if (x >  32767)  x = 32767;
        if (x < -32767) x = -32767;
        pIn[k] = (S16)x;
    }
}

/*-------------------------------------------------------------------------*/
int                     str_cmp
/*-------------------------------------------------------------------------*/
(
const char *pBasis, 
char **ppArg
)
{
    if (_strnicmp(pBasis, *ppArg, strlen(pBasis)) == 0)
    {
        *ppArg += strlen(pBasis);
        return 0;
    }
    else
    {
        return -1;
    }
}
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/

/*                  C O N F I G U R A T I O N                              */

/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/

/*-------------------------------------------------------------------------*/
int                     get_cfg_line
/*-------------------------------------------------------------------------*/
(
char *pArg
)
/* returns :
        0 - no errs
        1 - file err
        2 - arg scanf err
        3 - switch err
        */
{
    int Rc = 0;
    float Tmp;
    int iTmp;
    

    if ( *pArg == '-' || *pArg == '/')
    {
        pArg++;

        if (str_cmp("DBG", &pArg) == 0)
	    {
		    _Control.pDbgFile = fopen("dbg.txt", "w");
		    if ( _Control.pDbgFile == NULL )
		    {
			    Rc = 1;
		    } /* end-of-if */
	    }
	    else if (str_cmp("OUT", &pArg) == 0)
	    {
		    _Control.pOutFile = fopen("out.txt", "w");
		    if ( _Control.pOutFile == NULL )
		    {
			    Rc = 1;
		    } /* end-of-if */
	    }
	    else if (str_cmp("TMP", &pArg) == 0)
	    {
		    _Control.pTmpFile = fopen("tmp.txt", "w");
		    if ( _Control.pTmpFile == NULL )
		    {
			    Rc = 1;
		    } /* end-of-if */
	    }
	    else if (str_cmp("BYPASS", &pArg) == 0)
	    {
		    if (sscanf(pArg, "%f", &Tmp) != 1)
		    {
                Rc = 2;
		    }
            else
            {
                _Control.fDelay = Tmp;
            }
	    }
	    else if (str_cmp("GRMODE", &pArg) == 0)
	    {
		    if (sscanf(pArg, "%d", &_Control.iGmode) != 1)
            {
                Rc = 2;
            }
	    }
	    else if (str_cmp("CATCH", &pArg) == 0)
	    {
		    if (sscanf(pArg, "%d", &_Control.iCatch) != 1)
            {
                Rc = 2;
            }
	    }
        else if (str_cmp("STEPMODE", &pArg) == 0)
	    {
		    if (sscanf(pArg, "%d", &iTmp) != 1)
		    {
                Rc = 2;
		    }
            else
            {
    		    DEMO_StepMode = iTmp;
            }
	    }
        else if (str_cmp("SERIASTOP", &pArg) == 0)
	    {
		    if (sscanf(pArg, "%d", &iTmp) != 1)
		    {
                Rc = 2;
		    }
            else
            {
    		    _Control.iSeriaStop = iTmp;
            }
	    }
        else if (str_cmp("SAMEMAX", &pArg) == 0)
		{
			if (sscanf(pArg, "%d", &iTmp) != 1)
			{
                Rc = 2;
			}
            else
            {
				_Gen.iSameMax = iTmp;
            }
		}
        else if (str_cmp("SAMESTOP", &pArg) == 0)
	    {
		    if (sscanf(pArg, "%d", &iTmp) != 1)
		    {
                Rc = 2;
		    }
            else
            {
    		    _Control.iSameStop = iTmp;
            }
	    }
        else if (str_cmp("INPUT", &pArg) == 0)
	    {
		    _Control.pInFile = fopen(pArg+1, "rb");
		    if ( _Control.pInFile == NULL )
		    {
			    Rc  = 1;
		    } /* end-of-if */
            else
            {
				if (_Control.fDelay > 0)
				{
					for (long i = 0; i < _Control.fDelay * 8000; i++)
					{
						S16 x;
						fread(&x, sizeof(S16), 1, _Control.pInFile);
						if (i%8000 == 0)
						{
							val_out(0,0, WHITE, "second %ld   ", (i+1)/8000);
						}
					}
				}

            }
	    }
        else if (str_cmp("INCOR", &pArg) == 0)
	    {
		    if (sscanf(pArg, "%f", &Tmp) != 1)
		    {
                Rc = 2;
		    }
            else
            {
                _Control.fRxCorr = pow(10., Tmp/20.);
            }
        }
        else if (str_cmp("FILTER", &pArg) == 0)
	    {
   		    _Control.pFltFile = fopen(pArg+1, "r");
		    if ( _Control.pFltFile == NULL )
		    {
			    Rc  = 1;
		    } /* end-of-if */
            else
            {
                S16 k;
                for (k=0; k < _RX_FLT_SZ; k++)
                {
                    fscanf(_Control.pFltFile, "%f", &Tmp);
                    _afRxFlt[k] = Tmp;
                }
            }
        }
        else if (str_cmp("DF1", &pArg) == 0)
	    {
		    if (sscanf(pArg, "%f", &Tmp) != 1)
		    {
                Rc = 2;
		    }
            else
            {
                _Gen.fDf1 = Tmp;
            }
        }
        else if (str_cmp("DF2", &pArg) == 0)
	    {
		    if (sscanf(pArg, "%f", &Tmp) != 1)
		    {
                Rc = 2;
		    }
            else
            {
                _Gen.fDf2 = Tmp;
            }
        }
        else if (str_cmp("RXLEVEL", &pArg) == 0)
        {
			if (sscanf(pArg, "%f", &Tmp) != 1)
			{
                Rc = 2;
			}
            else
            {
				_Gen.iRxLevel = int(LEV0 * pow (10.0, Tmp/20.0) * 1.41);
            }
		}
        else if (str_cmp("NOISE", &pArg) == 0)
		{
			if (sscanf(pArg, "%f", &Tmp) != 1)
			{
                Rc = 2;
			}
            else
            {
				_Gen.iRxNoise = int(LEV0 * pow (10.0, Tmp/20.0));
            }
		}
        else if (str_cmp("SILENCE", &pArg) == 0)
		{
			if (sscanf(pArg, "%d", &iTmp) != 1)
			{
                Rc = 2;
			}
            else
            {
				_Gen.iSilence = iTmp*20;
            }
		}
        else if (str_cmp("SEIZURE", &pArg) == 0)
		{
			if (sscanf(pArg, "%d", &iTmp) != 1)
			{
                Rc = 2;
			}
            else
            {
				_Gen.iSeizure = iTmp*20;
            }
		}
        else if (str_cmp("MARKS", &pArg) == 0)
		{
			if (sscanf(pArg, "%d", &iTmp) != 1)