demo.cpp

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

/*-------------------------------------------------------------------------*
 *                                                                         *
 *   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 "clidi.h"

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

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

#define _RX_FLT_SZ  50
#define RX_DELAY 0
#define LEV0 (4096.0)
#define _CAS_MODE   (0)
#define X0 10
#define DX   5

#define IFR_MAX 9
#define XI  X0
#define YI  223
#define YIA 50


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

#define YE0     (450)
#define YS0     (330)

#define YEDBMAX (+6)
#define YEDBMIN (-60)
#define DBE2PX  (3)

#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;
    int iSameStop;
    double fRxCorr;
	FILE *pFltFile;
	FILE *pInFile;
    FILE *pDbgFile;
	FILE *pOutFile;
	FILE *pTmpFile;
} tControl;


typedef struct tGen {
    double fPhase;
    double fDf1;
    double fDf2;
    long lSample;
	int iRxNoise;
	int iRxLevel;

    int iSilence;
    int iSeizure;
    int iMarks;
    int iBytes;

    int iState;
    int aMsg[255];
    int iBit;
    int iBitNo;
    int iByteNo;
    int iSame;
    int iSameMax;
    int iFinished;

    int iChar;
    int iCS;
    int iMaxBitNo;

    S16 sMode;
    double fFreqDev;
    int iFreqSteps;
    int iFreqCntr;
    int iLoIdx;
    int iHiIdx;
    double fRxLoLevel;
    double fRxHiLevel;
    double fLoDev;
    double fHiDev;
    int iPreSilenceDuration;
    int iSignalDuration;
    int iPostSilenceDuration;
} tGen;

typedef struct tStat {
    S16 sEnd;
    S16 sStart;
    S16 sAbort;
    S16 sCas;
    S16 sLastStart;
    S16 sErrs;
    S32 lBytes;
} tStat;

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

U16         DEMO_StepMode;

/*--------------------- local vars ----------------------------------------*/
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,
};

double      _afRxFlt[_RX_FLT_SZ];
tStat       _Stat;
long        _Frame;
S16         _aRx[ICLID_FR_SZ*2+1];
S16         _asReadTmp[ICLID_FR_SZ];

TG_tDb      _TgDb;
TG_tCfg     _TgCfg;

TG_tDb      _AddTgDb;
TG_tCfg     _AddTgCfg;

TG_tScratch _TgScratch;

CLID_tDb        _ClidDb;
CLID_tSc        _ClidSc;
ICLID_tCfg      _ClidCfg;
ICLID_Status    _ClidStatus;

U16 auClidBuf[128];

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 = 0;
	int Tries  = 0;
	int Rx;

#if 0
    Read = fread(_asReadTmp, sizeof(S16), ICLID_FR_SZ, _Control.pInFile);
#else
    for (k = 0; k < ICLID_FR_SZ; k++)
    {
        Read += fscanf(_Control.pInFile, "%d", &Rx);
        _asReadTmp[k] = Rx;
    }
#endif
    if (Read != ICLID_FR_SZ)
    {
        DEMO_StepMode = TRUE;
		rewind(_Control.pInFile);
        for(k = 0; k < ICLID_FR_SZ; k++) pIn[k] = 0;
    }
    else
    {
	    for (k = 0; k < ICLID_FR_SZ; k++)
	    {
			Rx = int(_asReadTmp[k] * _Control.fRxCorr);
			if (Rx > 8159) Rx = 8159;
			if (Rx < -8159) Rx = -8159;
            *pIn++ = Rx;
		}
	}
}

/*-------------------------------------------------------------------------*/
double                     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 f;
}
/*-------------------------------------------------------------------------*/
void                    add_noise
/*-------------------------------------------------------------------------*/
(
double fNorma, 
double *pfIn
)
{
    S16 k;
    for(k = 0; k<ICLID_FR_SZ; k++)
    {
        pfIn[k] += gen_rand(fNorma);
    }
}

/*-------------------------------------------------------------------------*/
void                       _init_gen_clid                    
/*-------------------------------------------------------------------------*/
(
)
{
    _Gen.iFinished = 0;
    _Gen.lSample = 0;
    _Gen.iState = 0;
    _Gen.iBitNo = 0;
    _Gen.iByteNo = 0;
    _Gen.fPhase = (rand() * 2. * M_PI)/RAND_MAX;
}

/*-------------------------------------------------------------------------*/
double                      _gen_clid24                    
/*-------------------------------------------------------------------------*/
(
)
{
    int iPart; 
    int iAmp = 0;

    _Gen.lSample++;
    iPart = int(_Gen.lSample%20);

    switch (_Gen.iState)
    {
    case 0: // silence
		if (_Gen.lSample > _Gen.iSilence)
		    _Gen.iState = 1;
		_Gen.iBit = 0;
		iAmp = 0;
        break;
    case 1: // seizure 01010101
		if (iPart == 0)
        {
		    _Gen.iBit = !_Gen.iBit;
        }
		if (_Gen.lSample > (_Gen.iSilence + _Gen.iSeizure))
		    _Gen.iState = 2;
        iAmp = 1;
		break;
    case 2: // marks
		_Gen.iBit = 1;
		if (_Gen.lSample > (_Gen.iSilence + _Gen.iSeizure + _Gen.iMarks))
			_Gen.iState = 3;
        iAmp = 1;
		break;
    case 3: // message
        iAmp = 1;
		if (iPart == 0)
		{
			if (_Gen.iBitNo == 0)
			{
                if (_Gen.iByteNo == 0)
                {
                    _Gen.iChar = 0x04;
                    // for call waiting
//                    _Gen.iChar = 0x0a;
                    _Gen.iCS = _Gen.iChar;
                }
                else if (_Gen.iByteNo == 1)
                {
                    _Gen.iChar = _Gen.iBytes;
                    _Gen.iCS += _Gen.iChar;
                }
                else if (_Gen.iByteNo < (_Gen.iBytes + 2))
                {
  	    			_Gen.iChar = rand() & 0xff;
                    _Gen.iCS += _Gen.iChar;
                }
                else
                {
                    _Gen.iChar = 0x100 - (_Gen.iCS & 0xff);
                }
  				_Gen.iMaxBitNo = rand()%10 + 9;
//  				_Gen.iMaxBitNo = 20;
	    		_Gen.aMsg[(_Gen.iByteNo & 0xff)] = _Gen.iChar;
		    	_Gen.iBit = 0; // start

                _Gen.iByteNo++;
                if (_Gen.iByteNo > (_Gen.iBytes + 3))
                {
                    iAmp = 0;
                    _Gen.iFinished = 1;
                }
			}
			else if ((_Gen.iBitNo > 0) && (_Gen.iBitNo < 9))
			{
				_Gen.iBit = 0;
				if (_Gen.iChar & (1 << (_Gen.iBitNo-1)))
					_Gen.iBit = 1;
			}
			else // if (_Gen.iBitNo >= 9) // stop & marks between bytes
			{
				_Gen.iBit = 1;
                if (_Gen.iBitNo >= (_Gen.iMaxBitNo - 1))
                // last
                {
                    _Gen.iBitNo = -1;
                }
			}
			_Gen.iBitNo++;
		}
        break;
    default:
        break;
    } // end of switch

	if(_Gen.iBit) //mark
	{
		_Gen.fPhase += (1200.0+_Gen.fDf1)/24000.0 * 2.0 * M_PI;
	}
	else
	{
		_Gen.fPhase += (2200.0+_Gen.fDf2)/24000.0 * 2.0 * M_PI;
	}

	return (sin(_Gen.fPhase) * iAmp);
}
/*-------------------------------------------------------------------------*/
double                  _filter_it
/*-------------------------------------------------------------------------*/
(
double x
)
{
    static double aHst[_RX_FLT_SZ];

    int k;
    for (k = 0; k < _RX_FLT_SZ-1; k++)
    {
        aHst[k] = aHst[k+1];
    }
    aHst[_RX_FLT_SZ-1] = x;

    x = 0;
    for(k = 0; k < _RX_FLT_SZ; k++)
    {
        x += aHst[_RX_FLT_SZ-1-k] * _afRxFlt[k];
    }
    return x;
}
/*-------------------------------------------------------------------------*/
S16                     _gen_clid                
/*-------------------------------------------------------------------------*/
(
double *pfTo
)
{
    int k;

    for (k = 0; k < ICLID_FR_SZ; k++)
    {
        double fVal;

        _gen_clid24();
        _gen_clid24();
        fVal = _gen_clid24();
        fVal = _filter_it(fVal);

        *pfTo++ = fVal * _Gen.iRxLevel;
    }

    return _Gen.iFinished;
}

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

/*-------------------------------------------------------------------------*/
void                    _cas_config
/*-------------------------------------------------------------------------*/
(
)
{
    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);
    }

    _TgCfg.Lo.sFreq = (S16)((32768./4000.)*2130.0); 
    _TgCfg.Hi.sFreq = (S16)((32768./4000.)*2750.0); 
    _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);
}