main.c

Express DSP compliant C55x DTMF detector software is proposed in two versions: one with a 5 ms frame

/*-------------------------------------------------------------------------*
 *                                                                         *
 *   THIS IS AN UNPUBLISHED WORK CONTAINING CONFIDENTIAL AND PROPRIETARY   *
 *   INFORMATION.  IF PUBLICATION OCCURS, THE FOLLOWING NOTICE APPLIES:    *
 *      "COPYRIGHT 2001 MIKET DSP SOLUTIONS, ALL RIGHTS RESERVED"          *
 *                                                                         *
 *-------------------------------------------------------------------------*/
#include "dtmfi.h"
#include "tg.h"

#include <stdlib.h>

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

#define STD_FR_SZ (40) 

#if (STD_FR_SZ != ITG_FR_SZ)
#error tg frame size err
#endif               
#if (STD_FR_SZ != IDTMF_FR_SZ)
#error dtmf frame size err
#endif               

#define DBG_IT (11)

#define DTMF_RUN_SZ 2000

#define FR_MAX	(200)

#define dbs(x) ((S16)(170.1*x))
/*--------------------- public vars ---------------------------------------*/
/*--------------------- local vars ----------------------------------------*/

volatile S16 sErr = 0;
volatile S32 slA, slC;
volatile S16 sA, sC;
volatile S32 slCntr = 0;
volatile S16 k;

TG_tDb TgDb;
TG_tSc TgSc;
ITG_Status TgCfg;
IDTMF_Status DtmfStatus;
IDTMF_tCfg DtmfCfg;  

DTMF_tDb DtmfDbA; 
DTMF_tSc DtmfScA;
DTMF_tDb DtmfDbC; 
DTMF_tSc DtmfScC;

#pragma DATA_SECTION(DtmfScC, ".data_s");
#pragma DATA_SECTION(DtmfScA, ".data_s");

S16 asErrPosDb[8];
S16 asErrPosSc[32];

#pragma DATA_ALIGN(asRx, 2)
S16	asRx[STD_FR_SZ];

#pragma DATA_ALIGN(asRxC, 2)
S16	asRxC[STD_FR_SZ];

#pragma DATA_ALIGN(asTx, 2)
S16 asTx[STD_FR_SZ*FR_MAX];

S16 asReply[DTMF_RUN_SZ];

/*--------------------- local functions -----------------------------------*/
/*-------------------------------------------------------------------------*/
void                     tg_config
/*-------------------------------------------------------------------------*/
(
)
{
    TG_MIKET_control(&TgDb, ITG_CMD_RESET, &TgCfg);

    TgCfg.Lo.sFreq = (S16)((32768./4000.)*(770.0*0.995)); 
    TgCfg.Lo.sAmp = 2048;
    TgCfg.Hi.sFreq = (S16)((32768./4000.)*(941.0*1.005));
    TgCfg.Hi.sAmp = 2048;
#if 0    
    TgCfg.sPreSilenceDuration =  (S16) (15/(STD_FR_SZ/8));
    TgCfg.sSignalDuration =      (S16) (45/(STD_FR_SZ/8));
    TgCfg.sPostSilenceDuration = (S16) (35/(STD_FR_SZ/8));
#else    
    TgCfg.sPreSilenceDuration =  (S16) 0;
    TgCfg.sSignalDuration =      (S16) -1;
    TgCfg.sPostSilenceDuration = (S16) (35/(STD_FR_SZ/8));
#endif    
    TG_MIKET_control(&TgDb, ITG_CMD_TONE, &TgCfg);
}
/*-------------------------------------------------------------------------*/
void                     tg_config_tone
/*-------------------------------------------------------------------------*/
(
)
{
    TG_MIKET_control(&TgDb,ITG_CMD_RESET, &TgCfg);

    TgCfg.Lo.sFreq = (S16)((32768./4000.)*(770.0)); 
    TgCfg.Lo.sAmp = 8192;
    TgCfg.Hi.sFreq = (S16)((32768./4000.)*(1477.0));
    TgCfg.Hi.sAmp = 8192;
    TgCfg.sPreSilenceDuration =  (S16) (25/(STD_FR_SZ/8));
    TgCfg.sSignalDuration =      (S16) (55/(STD_FR_SZ/8));
    TgCfg.sPostSilenceDuration = (S16) (20/(STD_FR_SZ/8));
    
    TG_MIKET_control(&TgDb, ITG_CMD_TONE,&TgCfg);
}
/*-------------------------------------------------------------------------*/
void                     dtmf_config
/*-------------------------------------------------------------------------*/
(
)
{
    DtmfCfg.sFwdTwistThr  = dbs(4.0);
    DtmfCfg.sRevTwistThr  = dbs(8.0);
    DtmfCfg.sMinEnThr     = dbs(-40.0);
    DtmfCfg.sNoiseThr     = dbs(10.25);
    DtmfCfg.sSumEnThr     = dbs(1.75);
    DtmfCfg.sVarThr       = dbs(2.0);
    DtmfCfg.s2kUpThr      = dbs(11.0);
    DtmfCfg.sPartThr      = dbs(2.0);
    DtmfCfg.sCleanThr     = dbs(10.75);
    DtmfCfg.sMaxFreqDevThr = dbs(2.0);
    DtmfCfg.sMinToneDuration = 1;
    DtmfCfg.sMinPostSilenceDuration = 2;
    DtmfCfg.sAbortTimeout = 2;
}    
/*-------------------------------------------------------------------------*/
void 						fill_rand
/*-------------------------------------------------------------------------*/
(
S16 *pTo,
S16 sSz,
S16 sLevel
)
{
	S16 k;
	for (k = 0; k < sSz; k++)
	{
		S16 x = rand() - (RAND_MAX/2);
		x  = (S16)((x * (S32)sLevel)>>14); /* /RAND_MAX = 32767 */
		pTo[k] = x;
	}
}

/*-------------------------------------------------------------------------*/
S16 						compare
/*-------------------------------------------------------------------------*/
(
S16 *psIn,
S16 *psInC,
S16 sSz
)
{
	S16 k;     
	S16 err = 0;
	
	for (k = 0; k < sSz; k++)
	{
		if(psIn[k] != psInC[k])err++;
	}      
	return err;
}
/*-------------------------------------------------------------------------*/
S16 						compare_db
/*-------------------------------------------------------------------------*/
(
)
{
	S16 *psC = (S16 *)&DtmfDbC;
	S16 *psA = (S16 *)&DtmfDbA;
	S16 s;     
	S16 err = 0;

	for (s = 0; s < 8; s++)asErrPosDb[s] = 0;
	
	for (s = 0; s < sizeof(DtmfDbC); s++)
	{
		if(psA[s] != psC[s])
		{
			err++;
			if (err < 8)
			{
				asErrPosDb[err] = s;
			}
		}
		asErrPosDb[0] = err;
	}
	return err;
}
/*-------------------------------------------------------------------------*/
S16 						compare_sc
/*-------------------------------------------------------------------------*/
(
)
{
	S16 *psC = (S16 *)&DtmfScC;
	S16 *psA = (S16 *)&DtmfScA;
	S16 s;     
	S16 err = 0;
	
	for (s = 0; s < 32; s++)asErrPosSc[s] = 0;
	
	for (s = 0; s < sizeof(DtmfScC); s++)
	{
		if(psA[s] != psC[s])
		{
			err++;
			if (err < 32)
			{
				asErrPosSc[err] = s;
			}
		}
		asErrPosSc[0] = err;
	}
	return err;
}
extern S32 dtmf_frame_energyC(S16*);
extern S16 dtmf_en2logC(S32 );
extern S16 dtmf_frame_enlog(S16 *);
extern S16 dtmf_frame_enlogC(S16 *);
extern S16 dtmf_2k_filterC(S16 *psTo, S16 *psFrom);

/*--------------------- public  functions ---------------------------------*/

/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
void						main
/*-------------------------------------------------------------------------*/
(
)
{
	memset (DtmfDbC, 0, sizeof(DtmfDbC));	
	memset (DtmfDbA, 0, sizeof(DtmfDbA));	
	memset (DtmfScC, 0, sizeof(DtmfScC));	
	memset (DtmfScA, 0, sizeof(DtmfScA));	
	sErr = 0;
	
#if (DBG_IT == 0)
	if (DTMF_MIKET_DB_LSZ != sizeof(DTMF_tDb)/2)
		sErr++;
	if (DTMF_MIKET_SC_LSZ != sizeof(DTMF_tSc)/2)
		sErr++;
	test_asm();
#elif (DBG_IT == 1)

    TG_create(&TgDb);
    TG_init(&TgDb);
    tg_config();
    memset(asTx, 0, FR_MAX*STD_FR_SZ);
    for (k = 0; k < FR_MAX; k++)
    {
    	S16 sState = TG_process(&TgDb, &TgSc, &asTx[k*STD_FR_SZ]);
    	if (sState == 0)
    	{
    		tg_config();
    	}
    }
    tg_config();
#elif (DBG_IT == 2)
	for (k = 0; k< 100; k++)
	{
		fill_rand(asRx, STD_FR_SZ, 4000);
		slA = dtmf_frame_energy(asRx);
		slC = dtmf_frame_energyC(asRx);
		if (slA != slC)	sErr++;
	}
#elif (DBG_IT == 3)
	for (k = 0; k< 100; k++)
	{
		fill_rand(asRx, STD_FR_SZ, 4000);
		slA = dtmf_frame_energy(asRx);
		slC = dtmf_frame_energyC(asRx);
		sA = dtmf_en2log(slA>>4);		
		sC = dtmf_en2logC(slA>>4);		
		if (sA != sC) sErr++;
	}
#elif (DBG_IT == 4)
	for (k = 0; k< 100; k++)
	{
		fill_rand(asRx, STD_FR_SZ, 4000);
		sA = dtmf_frame_enlog(asRx);
		sC = dtmf_frame_enlogC(asRx);
		if (sA != sC) sErr++;
	}
#elif (DBG_IT == 5)
	for (k = 0; k< 100; k++)
	{
		extern S16 dtmf_2k_filterC(S16 *asRxC, S16 *asTx);
		extern S16 dtmf_2k_filter(S16 *asRxC, S16 *asTx);
		
		fill_rand(asTx, STD_FR_SZ+DTMF_2KFLT_SZ, 4000);
		sC = dtmf_2k_filterC(asRxC, asTx);
		sA = dtmf_2k_filter(asRx, asTx);
		if (sA != sC)	sErr++;
		if(compare(asRx, asRxC, STD_FR_SZ/2)) sErr++;
	}
#elif (DBG_IT == 6)
	{
		extern S32 dtmf_bp_filterC(S16 *psTo, S16 *psFrom, const S16 *psIFlt, const S16 *psQFlt);
		extern S32 dtmf_bp_filter(S16 *psTo, S16 *psFrom, const S16 *psIFlt, const S16 *psQFlt);
		extern const S16 dtmf_aLoBpI[];
		extern const S16 dtmf_aLoBpQ[];

		for (k = 0; k< 100; k++)
		{
			fill_rand(asTx, STD_FR_SZ+DTMF_BPFLT_SZ, 4000);
			slC = dtmf_bp_filterC (asRxC, asTx, dtmf_aLoBpI, dtmf_aLoBpQ);
			slA = dtmf_bp_filter  (asRx,  asTx, dtmf_aLoBpI, dtmf_aLoBpQ);
			if (slA != slC)	sErr++;
			if(compare(asRx, asRxC, 8)) sErr++;
		}
	}
#elif (DBG_IT == 7)
	{
		extern S32  dtmf_dial_filterC(S16 *psFrom, const S16 *psIFlt, const S16 *psQFlt);
		extern S32  dtmf_dial_filter(S16 *psFrom, const S16 *psIFlt, const S16 *psQFlt);
		extern const S16 dtmf_aDialI[];
		extern const S16 dtmf_aDialQ[];

		for (k = 0; k< 100; k++)
		{
			fill_rand(asTx, STD_FR_SZ+DTMF_BPFLT_SZ, 4000);
			slC = dtmf_dial_filterC (asTx, dtmf_aDialI, dtmf_aDialQ);
			slA = dtmf_dial_filter  (asTx, dtmf_aDialI, dtmf_aDialQ);
			if (slA != slC)	sErr++;
		}
	}
#elif (DBG_IT == 8)
	{
#define DFT_SZ (12)	
		extern void dtmf_dftC(S16 sSz,S16 *psOut,S16 *psIn, const S16 *psFlt);
		extern void dtmf_dft(S16 sSz,S16 *psOut,S16 *psIn, const S16 *psFlt);
		extern const S16 dtmf_aLo[];

		for (k = 0; k< 100; k++)
		{
			fill_rand(asTx, DFT_SZ*2, 1000);
			dtmf_dftC (DFT_SZ, asRxC, asTx, dtmf_aLo);
			dtmf_dft  (DFT_SZ, asRx,  asTx, dtmf_aLo);
			if(compare(asRx, asRxC, 4)) sErr++;
		}
	}
#elif (DBG_IT == 9)
	{
		extern S16 dtmf_sort_freqC(S16 *psOut,S16 *psIn);
		extern S16 dtmf_sort_freq(S16 *psOut,S16 *psIn);

		for (k = 0; k< 100; k++)
		{
			fill_rand(asTx, 4, 1000);
			sC = dtmf_sort_freqC (asRxC, asTx);
			sA = dtmf_sort_freq  (asRx, asTx);
			if (sA != sC)	sErr++;
			if(compare(asRx, asRxC, 1)) sErr++;
		}
	}
#elif (DBG_IT == 10)
#define M8 (800)
	{
		extern S16 dtmf_get_freq_deviationC(S16 *psDev,
				const S16 *psDevFlt,S16 *psFreqDev);
		extern S16 dtmf_get_freq_deviation(S16 *psDev,
				const S16 *psDevFlt,S16 *psFreqDev);
	
		static const S16 aasLoDevFlt[4][2] = 
		{
    		{23220,  77},
    		{18493,  90},
    		{14473,  112},
    		{11353,  139}
		};
		for (k = 0; k< 100; k++)
		{
			fill_rand(asTx, 4, M8*2);
			asTx[0] -= M8;
			asTx[1] += M8*2;
			asTx[2] += M8;
			asTx[3] -= M8*2;
			sC = dtmf_get_freq_deviationC(asTx, &aasLoDevFlt[3][0], asRxC);
			sA = dtmf_get_freq_deviation (asTx, &aasLoDevFlt[3][0], asRx );
			if (sA != sC)	sErr++;
			if(compare(asRx, asRxC, 1)) sErr++;
		}
	}
#elif (DBG_IT == 11)
/*	DTMF_create(&DtmfDbA);
	DTMF_create(&DtmfDbC); */

	dtmf_config();

    DTMF_MIKET_init_db(&DtmfDbA, &DtmfCfg);
    DTMF_MIKET_init_db(&DtmfDbC, &DtmfCfg); 
//    DtmfStatus.pCfg = &DtmfCfg;
//    DTMF_MIKET_control(&DtmfDbA, IDTMF_CMD_CFG, &DtmfStatus);
//    DTMF_MIKET_control(&DtmfDbC, IDTMF_CMD_CFG, &DtmfStatus);
    
    TG_MIKET_init(&TgDb);
	tg_config_tone();

	for (k = 0; k < DTMF_RUN_SZ; k++)
	{
		S16 sState;
		
		fill_rand(asRx, STD_FR_SZ, 1000);
		sState = TG_MIKET_process(&TgDb, &TgSc, asRx); 
		if (sState == 0)
		{
			tg_config_tone();
		}
		memset(&DtmfScA, 0, sizeof(DtmfScA));
		memset(&DtmfScC, 0, sizeof(DtmfScC));
		DTMF_MIKET_processC(&DtmfDbC, &DtmfScC, asRx);   
		asReply[k] = DTMF_MIKET_process(&DtmfDbA, &DtmfScA, asRx);

		if(compare_db()) sErr++;
		if(compare_sc()) sErr++;
		
		if (sErr)
		{
			sErr = dtmf_en2log((S32)sErr);
		} 
		
	}
#elif (DBG_IT == 12)
	for (k = 0; k < 2000; k++)
	{
		
		extern void	filter_2k(DTMF_tDb *pDb,DTMF_tSc *pSc);
		extern void	filter_2kA(DTMF_tDb *pDb,DTMF_tSc *pSc);
		
		memset(&DtmfSc, 0, sizeof(DtmfSc));
		memset(&DtmfScC, 0, sizeof(DtmfSc));
/*		fill_rand(DtmfSc.as2kData, STD_FR_SZ+DTMF_2KFLT_SZ, 3000); */
		fill_rand(&DtmfSc.as2kData[DTMF_2KFLT_SZ], STD_FR_SZ, 3000);
		{
			S16 kk;
			for (kk = 0; kk < STD_FR_SZ; kk++)
			{
				DtmfSc.as2kData[DTMF_2KFLT_SZ+kk] >>= 3;
			}
		}
		memcpy(DtmfScC.as2kData, DtmfSc.as2kData,STD_FR_SZ+DTMF_2KFLT_SZ); 
		
		filter_2k(&DtmfDbC, &DtmfScC);   
		filter_2kA(&DtmfDb, &DtmfSc);
		
		if(compare(
			(S16 *)&DtmfSc.asBpData[DTMF_BPFLT_SZ], 
			(S16 *)&DtmfScC.asBpData[DTMF_BPFLT_SZ], 
			STD_FR_SZ/2)) sErr++;
		if(DtmfSc.s2kEnDlt != DtmfScC.s2kEnDlt) sErr++;
	}
#endif
	stop_asm();	
	{
		for(;;)
		{
			slCntr++;
			dtmf_en2log(slCntr);
		}
	}
}