demo.cpp

CP detector (CPD) only reports the onset and removal of a tone. The analysis of timing (if required)

/*-------------------------------------------------------------------------*
 *                                                                         *
 *   THIS IS AN UNPUBLISHED WORK CONTAINING CONFIDENTIAL AND PROPRIETARY   *
 *   INFORMATION.  IF PUBLICATION OCCURS, THE FOLLOWING NOTICE APPLIES:    *
 *      "COPYRIGHT 2001 MICHAEL TSIROULNIKOV, ALL RIGHTS RESERVED"         *
 *                                                                         *
 *-------------------------------------------------------------------------*/



#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#define M_PI                3.14159265


#include "sim.h"
#include "demo.h"

#include "stddefs.h"
#include "tg.h"
#include "cpdi.h"

#include "stdafx.h"
#include <mmsystem.h> 

/*--------------------- local defs ----------------------------------------*/

#define RX_DELAY 32
#define LEV0 (4096.0)

#define X0 10
#define DX   5

#define IFR_MAX 25
#define XI  X0
#define YI  103
#define YIA 100


#define EDFR_MAX 200
#define XE1  (X0+DX*EDFR_MAX+20)

#define YS0  420
#define YE0  230
#define YD0  570

#define YEDBMAX (+6)
#define YEDBMIN (-60)
#define DBE2PX (3)
#define DBD2PX (10)
#define DM5    (5)

#define XTD 120
#define XT0 X0
#define XT1 XT0+XTD
#define XT2 XT1+XTD
#define XT3 XT2+XTD
#define XT4 XT3+XTD
#define XT5 XT4+XTD
#define XT6 XT5+XTD
#define XT7 XT6+XTD
#define XT8 XT7+XTD
#define XTM XT8+XTD

#define YTD 20
#define YT0 640
#define YT1 YT0+YTD
#define YT2 YT1+YTD
#define YT3 YT2+YTD
#define YT4 YT3+YTD
#define YT5 YT4+YTD
#define YT6 YT5+YTD
#define YT7 YT6+YTD
#define YT8 YT7+YTD

typedef struct tControl
{
	double fDelay;
    int iGmode;
    int iCatch;
    int iCatchCntr;
    int iSeriaStop;
    double fRxCorr;
	FILE *pInFile;
    FILE *pDbgFile;
	FILE *pOutFile;
	FILE *pTmpFile;
} tControl;


typedef struct tGen {
	int iRxNoise;
	int iRxHiLevel;
	int iRxLoLevel;
    int iPreSilenceDuration;
    int iSignalDuration;
    int iPostSilenceDuration;
    int iSameCntr;
    int iSameCntrMax;
    int iFreqCntr;
    int iFreqSteps;
    int iToneCntr;
    int iToneInc;
    S16 sFLo;
    S16 sFHi;
    int iLoIdx;
    int iHiIdx;
    double fLoDev;
    double fHiDev;
    double fFreqDevMax;
    struct {
    	int iLevel1;
	    int iLevel2;
        S16 iPreSilenceDuration;
        S16 iSignalDuration;
        S16 iPostSilenceDuration;
        int iFreq1;
        int iFreq2;
    } Rev;
} tGen;

typedef struct tStat {
    S16 sEnd;
    S16 sStart;
    S16 sAbort;
    S16 sLastStart;
} tStat;

/*--------------------- public vars ---------------------------------------*/

U16         DEMO_StepMode;

/*--------------------- local vars ----------------------------------------*/
U16         _uIsSeriaOver;
static char _aBuff[81];

tGen        _Gen;
tControl    _Control;

static int  _aiColor[10] = 
{
    RED, GREEN,
    3 , 3 +(2<<2), 3 +(3<<2), 3 +(3<<2) + 0x20,
    48, 48+(2<<2), 48+(3<<2), 48+(3<<2) + 0x02,
};

#define F1 (350)
#define F2 (400)
#define F3 (440)
#define F4 (480)
#define F5 (620)
#define F6 (0)

static struct {
    S16 sFLo;
    S16 sFHi;
} _aFreqs[15] = {

    {F1, F2}, // 0
    {F1, F3}, // 1
    {F1, F4}, // 2
    {F1, F5}, // 3
    {F1, F6}, // 4

    {F2, F3}, // 5
    {F2, F4}, // 6
    {F2, F5}, // 7
    {F2, F6}, // 8
    {F3, F4}, // 9

    {F3, F5}, // 10
    {F3, F6}, // 11
    {F4, F5}, // 12
    {F4, F6}, // 13
    {F5, F6}, // 14
};

static char _aaMfTable[6][6] = 
{
    {'?', '1', '2', '4', '7', 'b'},
	{'1', '?', '3', '5', '8', 'c'},
	{'2', '3', '?', '6', '9', 'd'},
	{'4', '5', '6', '?', 'a', 'e'},
	{'7', '8', '9', 'a', '?', 'f'},
	{'b', 'c', 'd', 'e', 'f', '?'}
};

tStat       _Stat;
long        _Frame;
long        _lStartFrame;
S16         _aRx[ICPD_FR_SZ*2+1];
S16         _asReadTmp[ICPD_FR_SZ];

TG_tDb      _TgDb;
TG_tCfg     _TgCfg;

TG_tDb      _RevDb;
TG_tCfg     _RevCfg;

TG_tScratch _TgScratch;

CPD_tDb    _CpdDb;
CPD_tSc    _CpdSc;
ICPD_tCfg    _CpdCfg;
ICPD_Status  _CPD_Status;

char *_acOn[] = 
{
    "off",
    "on"
};



/*--------------------- local functions -----------------------------------*/

void dump_results(void);


/*-------------------------------------------------------------------------*/
static void             _err
/*-------------------------------------------------------------------------*/
(
int no,
int line,
char *pStr
)
{
    val_out(400, 0, LIGHTRED, "ERR %d : %s (line %d)", no, pStr, line);
}


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

/*                  I N P U T ,  G E N E R A T O R                         */

/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
void                        read_input
/*-------------------------------------------------------------------------*/
(
S16 *pIn
)
{
	int k;
	int Read;
	int Tries  = 0;
	int Rx;

    Read = fread(_asReadTmp, sizeof(S16), ICPD_FR_SZ, _Control.pInFile);

    if (Read != ICPD_FR_SZ)
    {
        DEMO_StepMode = TRUE;
		rewind(_Control.pInFile);
        for(k = 0; k < ICPD_FR_SZ; k++) pIn[k] = 0;
    }
    else
    {
	    for (k = 0; k < ICPD_FR_SZ; k++)
	    {
			Rx = int(_asReadTmp[k] * _Control.fRxCorr);
			if (Rx > 8159) Rx = 8159;
			if (Rx < -8159) Rx = -8159;
            *pIn++ = Rx;
		}
	}
}

/*-------------------------------------------------------------------------*/
S16                     gen_rand
/*-------------------------------------------------------------------------*/
(
double fNorma
)
{
    double f = 0;
    S16 n;

    for (n = 0; n < 12; n++)
    {
        f += rand();
    }
    f = ((f - 6.0*RAND_MAX)* fNorma)/RAND_MAX;
    return (S16)f;
}
/*-------------------------------------------------------------------------*/
void                    add_noise
/*-------------------------------------------------------------------------*/
(
double fNorma, 
S16 *pIn
)
{
    S16 k;
    for(k=0; k<ICPD_FR_SZ; k++)
    {
        pIn[k] += gen_rand(fNorma);
    }
}
/*-------------------------------------------------------------------------*/
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.iSameCntr == _Gen.iSameCntrMax)
    {
        _TgCfg.Hi.sAmp = 0;
        _TgCfg.Lo.sAmp = 0;
    }
    else
    {
        _TgCfg.Hi.sAmp = _Gen.iRxHiLevel;
        _TgCfg.Lo.sAmp = _Gen.iRxLoLevel;
    }

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

    _TgCfg.Lo.sFreq = (S16)((32768./4000.)*(_Gen.sFLo + _Gen.fLoDev));
    _TgCfg.Hi.sFreq = (S16)((32768./4000.)*(_Gen.sFHi + _Gen.fHiDev));

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

    _TgCfg.sCmd = TG_CMD_RESET;
    TG_control(&_TgDb, &_TgCfg);

    _TgCfg.sCmd = TG_CMD_TONE;
    TG_control(&_TgDb, &_TgCfg);

    if ((fabs(_Gen.fLoDev) < 0.015) && (fabs(_Gen.fHiDev)< 0.015))
    {
        _Control.iCatchCntr = 14;
    }
    else
    {
        _Control.iCatchCntr = -1;
    }
}
/*-------------------------------------------------------------------------*/
void                    rev_config
/*-------------------------------------------------------------------------*/
(
)
{
    _RevCfg.sCmd = TG_CMD_RESET;

    TG_control(&_RevDb, &_RevCfg);

    _RevCfg.Lo.sAmp = _Gen.Rev.iLevel2;
    _RevCfg.Hi.sAmp = _Gen.Rev.iLevel1;
    _RevCfg.Lo.sFreq = (S16)((32768./4000.)*_Gen.Rev.iFreq1);
    _RevCfg.Hi.sFreq = (S16)((32768./4000.)*_Gen.Rev.iFreq2);

    _RevCfg.sPreSilenceDuration =  (S16) _Gen.Rev.iPreSilenceDuration/(ICPD_FR_SZ/8);
    _RevCfg.sSignalDuration =      (S16) _Gen.Rev.iSignalDuration/(ICPD_FR_SZ/8);
    _RevCfg.sPostSilenceDuration = (S16) _Gen.Rev.iPostSilenceDuration/(ICPD_FR_SZ/8);
    _RevCfg.sCmd = TG_CMD_TONE;

    TG_control(&_RevDb, &_RevCfg);
}

/*-------------------------------------------------------------------------*/
S16                     dbs
/*-------------------------------------------------------------------------*/
(
double dB
)
{
    return (S16)(dB*170.1);
}

/*-------------------------------------------------------------------------*/
void                        gen_input
/*-------------------------------------------------------------------------*/
(
S16 *pIn
)
{
    int k;

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

// add dtmf
    S16 sTgState = TG_process(&_TgDb, &_TgScratch, pIn);

    if (sTgState == 0)
    {
// next packet, the same tone.
        ++_Gen.iSameCntr;
        if (_Gen.iSameCntr == _Gen.iSameCntrMax+1)
        {
        	dump_results();
            if (_Control.iSeriaStop)
            {
                DEMO_StepMode = TRUE;
            }
            _uIsSeriaOver = TRUE;

            _Gen.iSameCntr = 0;
// next freq content within the same tone
            ++_Gen.iFreqCntr;