demo.cpp

来自「Express DSP compliant C55x DTMF detector」· C++ 代码 · 共 1,667 行 · 第 1/4 页

/*-------------------------------------------------------------------------*
 *                                                                         *
 *   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 "dtmf.h"
#include "dtmfi.h"

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

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

#define RX_DELAY 20
#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 (15)


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


typedef struct tGen {
	int iRxNoise;
	int iRxHiLevel;
	int iRxLoLevel;
    int iDialLevel;
    int iPreSilenceDuration;
    int iSignalDuration;
    int iPostSilenceDuration;
    int iSameCntr;
    int iSameCntrMax;
    int iFreqCntr;
    int iFreqSteps;
    int iToneCntr;
    int iToneInc;
    int iLo;
    int iHi;
    int iLoIdx;
    int iHiIdx;
    double fLoDev;
    double fHiDev;
    double fFreqDevMax;
} tGen;

typedef struct tStat {
    S16 sEnd;
    S16 sStart;
    S16 sEarlyOn;
    S16 sEarlyOff;
    S16 sAbort;
} tStat;

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

U16         DEMO_StepMode;
extern S16 DBG_sFrameEn;
extern S32 DBG_slDialEn;

/*--------------------- local vars ----------------------------------------*/

static char __aBuff[81];

tGen        __Gen;
tControl    __Control;

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

static S16  __asFlo[4] = { 697,  770,  852,  941};
static S16  __asFhi[4] = {1209, 1336, 1477, 1633};

static char __aaDtmfTable[4][4] = 
{
    {'1', '2', '3', 'A'},
	{'4', '5', '6', 'B'},
	{'7', '8', '9', 'C'},
	{'*', '0', '#', 'D'}
};

tStat       __Stat;
long        __Frame;
long        __lStartFrame;
S16         __aRx[STD_FR_SZ*2+1];
S16         __asReadTmp[STD_FR_SZ];

TG_tDb      __TgDb;
TG_tCfg     __TgCfg;

TG_tDb      __DialDb;
TG_tCfg     __DialCfg;
TG_tScratch __TgScratch;
TG_tScratch __DialScratch;

DTMF_tDb    __DtmfDb;
DTMF_tSc    __DtmfSc;
DTMF_tCfg   __DtmfCfg;

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), STD_FR_SZ, __Control.pInFile);

    if (Read != STD_FR_SZ)
    {
        DEMO_StepMode = TRUE;
		rewind(__Control.pInFile);
        for(k = 0; k < STD_FR_SZ; k++) pIn[k] = 0;
    }
    else
    {
	    for (k = 0; k < STD_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<STD_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.)*__asFlo[__Gen.iLo] * 
        (1.0 + __Gen.fLoDev));
    __TgCfg.Hi.sFreq = (S16)((32768./4000.)*__asFhi[__Gen.iHi] * 
        (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.015) && (fabs(__Gen.fHiDev)< 0.015))
    {
        __Control.iCatchCntr = 14;
    }
    else
    {
        __Control.iCatchCntr = -1;
    }
}

/*-------------------------------------------------------------------------*/
S16                     dbs
/*-------------------------------------------------------------------------*/
(
double dB
)
{
    return (S16)(dB*170.1);
}
/*-------------------------------------------------------------------------*/
void                     dial_config
/*-------------------------------------------------------------------------*/
(
)
{
    __DialCfg.sCmd = TG_CMD_RESET;
    TG_control(&__DialDb, &__DialCfg);

    if (__Gen.iDialLevel <= 2) return;

    __DialCfg.Lo.sPhase = 0;
    __DialCfg.Lo.sFreq = (S16)((32768./4000.)*(350.0*(1-.00)));
//    __DialCfg.Lo.sFreq = (S16)((32768./4000.)*(400.0));
    __DialCfg.Lo.sAmp = __Gen.iDialLevel;
    __DialCfg.Hi.sPhase = 0;
    __DialCfg.Hi.sFreq = (S16)((32768./4000.)*(440.0*(1-.00)));
//    __DialCfg.Hi.sFreq = (S16)((32768./4000.)*(0.0));
    __DialCfg.Hi.sAmp = __Gen.iDialLevel;
    __DialCfg.sPreSilenceDuration =  (S16) 5/(STD_FR_SZ/8);
    __DialCfg.sSignalDuration =      (S16) 250/(STD_FR_SZ/8);
    __DialCfg.sPostSilenceDuration = (S16) 250/(STD_FR_SZ/8);

// if continuous signal...
//    __DialCfg.sSignalDuration =      (S16) -1;

    __DialCfg.sCmd = TG_CMD_TONE;
    
    TG_control(&__DialDb, &__DialCfg);
}

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

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


// add dial tone
    if (__Gen.iDialLevel > 2)
    {
        if (TG_process(&__DialDb, &__DialScratch, pIn) == 0)
            dial_config();
    }

// add dtmf
    S16 sTgState = TG_process(&__TgDb, &__TgScratch, pIn);

    add_noise(__Gen.iRxNoise, pIn);

    if (sTgState == 0)
    {
// next packet, the same tone.
        ++__Gen.iSameCntr;
        if (__Gen.iSameCntr == __Gen.iSameCntrMax+1)
        {
        	dump_results();

//            DEMO_StepMode = TRUE;

            __Gen.iSameCntr = 0;
// next freq content within the same tone
            ++__Gen.iFreqCntr;
            if (__Gen.iFreqCntr >= 2*(2*__Gen.iFreqSteps+1))
            {
                __Gen.iFreqCntr = 0;
// next tone
                __Gen.iToneCntr += __Gen.iToneInc; 
                if (__Gen.iToneCntr >= 16) DEMO_StepMode = TRUE;

                __Gen.iToneCntr &= 0xf;
                __Gen.iLo = __Gen.iToneCntr % 4;
                __Gen.iHi = __Gen.iToneCntr / 4;

            }

        }
        tg_config();