main.c

用c语言写的基于TI的DSP平台的FSK制式的来电显示(CLID)的算法程序

#include "clidi.h"
#include <stdlib.h>


S16 asTx[ICLID_FR_SZ];
S16 asRxC[ICLID_FR_SZ];
S16 asRxA[ICLID_FR_SZ];
S16 aS[ICLID_FR_SZ*2];
S16 aC[ICLID_FR_SZ*2];


#pragma DATA_SECTION (ClidDbA, ".clidba");
#pragma DATA_SECTION (ClidDbC, ".clidbc");
#pragma DATA_SECTION (ClidScA, ".clidsa");
#pragma DATA_SECTION (ClidScC, ".clidsc");

CLID_tDb ClidDbA, ClidDbC;
CLID_tSc ClidScA, ClidScC;

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

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

/*-------------------------------------------------------------------------*/
void 						fill_rand
/*-------------------------------------------------------------------------*/
(
S16 *pTo,
S16 sSz,
S16 sLevel
)
{
	S16 s;
	for (s = 0; s < sSz; s++)
	{
		S16 x = rand() - (RAND_MAX/2);
		x  = (S16)((x * (S32)sLevel)>>14); /* /RAND_MAX = 32767 */
		pTo[s] = x;
	}
}

/*-------------------------------------------------------------------------*/
void 						fill_cnt
/*-------------------------------------------------------------------------*/
(
S16 *pTo,
S16 sSz,
S16 sStart
)
{
	S16 s;
	S16 x = sStart;
	for (s = 0; s < sSz; s++)
	{
		pTo[s] = x;
		x += 0x100;
	}
}

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

	for (s = 0; s < 8; s++)asErrPosDb[s] = 0;
	
	for (s = 0; s < sizeof(ClidDbC); s++)
	{
		if(psA[s] != psC[s])
		{
			err++;
			if (err < 8)
			{
				asErrPosDb[err] = s;
			}
		}
		asErrPosDb[0] = err;
	}
	return err;
}
/*-------------------------------------------------------------------------*/
S16 						compare_sc
/*-------------------------------------------------------------------------*/
(
)
{
	S16 *psC = (S16 *)&ClidScC;
	S16 *psA = (S16 *)&ClidScA;
	S16 s;     
	S16 err = 0;
	
	for (s = 0; s < 32; s++)asErrPosSc[s] = 0;
	/* last is ptr, which is different */
	/* all structures are long-word aligned */
	for (s = 0; s < sizeof(ClidScC); s++)
	{
		if(psA[s] != psC[s])
		{
			err++;
			if (err < 32)
			{
				asErrPosSc[err] = s;
			}
		}
		asErrPosSc[0] = err;
	}
	return err;
}
typedef struct {
	int iFinished;
	long lSample;
	int iState;
	int iBitNo;
	int iByteNo;
	int iSilence;
	int iSeizure;
	int iMarks;
	int iBit;
	int iChar;
	int iCS;
	int iBytes;
	int iMaxBitNo;
	int iRxLevel;
	U16 aMsg[256];
} tGen;
tGen _Gen;

float fPhase = 0.12345;

#define M_PI 3.14159265

/*-------------------------------------------------------------------------*/
void                       _init_gen_clid                    
/*-------------------------------------------------------------------------*/
(
)
{
    _Gen.iFinished = 0;
    _Gen.lSample = 0;
    _Gen.iState = 0;
    _Gen.iBitNo = 0;
    _Gen.iByteNo = 0;
    _Gen.iSilence = 5*20;
    _Gen.iSeizure = 300*20;
    _Gen.iMarks = 180*20;
    _Gen.iBytes = 50;
    _Gen.iBit = 0;
    _Gen.iRxLevel = 4000;
}
float sin(float);
/*-------------------------------------------------------------------------*/
float                      _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
	{
		fPhase += (1200.0)/24000.0 * 2.0 * M_PI;
	}
	else
	{
		fPhase += (2200.0)/24000.0 * 2.0 * M_PI;
	}
	
	for (; fPhase > 2*M_PI;)
	{
		fPhase -= 2*M_PI;
	}

	return sin(fPhase) * iAmp;
}
/*-------------------------------------------------------------------------*/
void                     _gen_clid                
/*-------------------------------------------------------------------------*/
(
S16 *pfTo
)
{
    int k;

    for (k = 0; k < ICLID_FR_SZ; k++)
    {
        float fVal;
        float _gen_clid24(void);

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

        *pfTo++ = (S16)(fVal * _Gen.iRxLevel);
    }
}

#define DBG_IT	(7)

void main ()
{
	memset(&ClidDbA, 0, sizeof(ClidDbA));	
	memset(&ClidDbC, 0, sizeof(ClidDbC));	
	memset(&ClidScA, 0, sizeof(ClidScA));	
	memset(&ClidScC, 0, sizeof(ClidScC));	
	sErr = 0;
	
#if (DBG_IT == 0)
	if (CLID_MIKET_DB_LSZ != sizeof(CLID_tDb)/2)
		sErr++;
	if (CLID_MIKET_SC_LSZ != sizeof(CLID_tSc)/2)
		sErr++;
		
	sC = _en2logC(0x12345678);	
	sA = _en2log(0x12345678);	
	if (sC-sA)	sErr++;
	
#elif (DBG_IT == 1)
	for (k = 0; k < 100; k++)
	{
		fill_rand(ClidScC.asBp, CLID_BPF_ASZ, 8000);
		memcpy(ClidScA.asBp, ClidScC.asBp, CLID_BPF_ASZ);
		clid_bp_filterC(&ClidDbC, &ClidScC);
		clid_bp_filter (&ClidDbA, &ClidScA);
		sErr += compare_db();
		sErr += compare_sc();
	}
#elif (DBG_IT == 2)
	for (k = 0; k < 100; k++)
	{
		fill_rand(ClidScC.asBp, CLID_BPF_ASZ, 8000);
		memcpy(ClidScA.asBp, ClidScC.asBp, CLID_BPF_ASZ);
		clid_bp_filter (&ClidDbC, &ClidScC);
		clid_bp_filter (&ClidDbA, &ClidScA);
		clid_convert_basebandC(&ClidDbC, &ClidScC);
		clid_convert_baseband (&ClidDbA, &ClidScA);
		sErr += compare_db();
		sErr += compare_sc();
	}
#elif (DBG_IT == 3)
	for (k = 0; k < 100; k++)
	{
		fill_rand(ClidScC.asBp, CLID_BPF_ASZ, 8000);
		memcpy(ClidScA.asBp, ClidScC.asBp, CLID_BPF_ASZ);
		clid_bp_filter (&ClidDbC, &ClidScC);
		clid_bp_filter (&ClidDbA, &ClidScA);
		clid_convert_baseband (&ClidDbC, &ClidScC);
		clid_convert_baseband (&ClidDbA, &ClidScA);
		clid_resample_6kC(&ClidDbC, &ClidScC);
		clid_resample_6k (&ClidDbA, &ClidScA);
		sErr += compare_db();
		sErr += compare_sc();
	}
#elif (DBG_IT == 4)
	for (k = 0; k < 100; k++)
	{
		fill_rand(ClidScC.asBp, CLID_BPF_ASZ, 8000);
		memcpy(ClidScA.asBp, ClidScC.asBp, CLID_BPF_ASZ);
		clid_bp_filter (&ClidDbC, &ClidScC);
		clid_bp_filter (&ClidDbA, &ClidScA);
		clid_convert_baseband (&ClidDbC, &ClidScC);
		clid_convert_baseband (&ClidDbA, &ClidScA);
		clid_resample_6k (&ClidDbC, &ClidScC);
		clid_resample_6k (&ClidDbA, &ClidScA);
//		ClidScA.sAlignment = ClidScC.sAlignment = (rand() - (RAND_MAX/2))>>3;
		clid_matched_filterC(&ClidDbC, &ClidScC);
		clid_matched_filter (&ClidDbA, &ClidScA);
		sErr += compare_sc();
		sErr += compare_db();
	}
#elif (DBG_IT == 5)
	for (k = 0; k < 100; k++)
	{
		fill_rand(ClidScC.asOut, CLID_OUT_ASZ, 8000);
		memcpy(ClidScA.asOut, ClidScC.asOut, CLID_OUT_ASZ);
		sC = clid_match_byteC (ClidScC.asOut + 5, (U16 *)&uC);
		sA = clid_match_byte (ClidScC.asOut + 5, (U16 *)&uA);
		if (sC != sA) sErr++;
		if (uC != uA) sErr++;
		sErr += compare_sc();
		sErr += compare_db();
	}
#elif (DBG_IT == 6)
	fill_rand((S16 *)&ClidDbC, sizeof(CLID_tDb), 8000);
	ClidDbC.Cfg.sNormShift = -3;
	fill_rand((S16 *)&ClidScC, sizeof(CLID_tSc), 8000);
	memcpy(&ClidDbA, &ClidDbC, sizeof(CLID_tDb));
	memcpy(&ClidScA, &ClidScC, sizeof(CLID_tSc));
	for (k = 0; k < 100; k++)
	{
		fill_rand(asRxA, ICLID_FR_SZ, 25000);

		clid_move_data_inC(&ClidDbC, &ClidScC, asRxA);
		clid_move_data_in (&ClidDbA, &ClidScA, asRxA);
		sErr += compare_db();
		sErr += compare_sc();

		clid_move_data_outC(&ClidDbC, &ClidScC);
		clid_move_data_out (&ClidDbA, &ClidScA);
		sErr += compare_db();
		sErr += compare_sc();
	}
#elif (DBG_IT == 7)
	{
		ICLID_Status Status;	
		CLID_MIKET_init_db(&ClidDbA, (ICLID_tCfg *)&ICLID_MIKET_DefaultCfg);
		CLID_MIKET_control(&ClidDbA, ICLID_CMD_TYPE1, &Status );
		_init_gen_clid();
		for (k = 0; k < 400; k++)
		{
			_gen_clid(asRxA);
			CLID_MIKET_process(&ClidDbA, &ClidScA, asRxA);
		}
	}
#elif (DBG_IT == 8)
#elif (DBG_IT == 9)
#elif (DBG_IT == 10)
#elif (DBG_IT == 11)
#elif (DBG_IT == 12)
#elif (DBG_IT == 13)
#elif (DBG_IT == 14)
#elif (DBG_IT == 15)
#elif (DBG_IT == 16)
#elif (DBG_IT == 17)
#elif (DBG_IT == 18)
#elif (DBG_IT == 19)
#elif (DBG_IT == 20)
#elif (DBG_IT == 21)
#elif (DBG_IT == 22)
#elif (DBG_IT == 23)
#elif (DBG_IT == 24)
#elif (DBG_IT == 25)
#elif (DBG_IT == 26)
#elif (DBG_IT == 27)
#elif (DBG_IT == 28)
#elif (DBG_IT == 29)
#elif (DBG_IT == 30)
#elif (DBG_IT == 31)
#elif (DBG_IT == 32)
#elif (DBG_IT == 33)
#elif (DBG_IT == 34)
#elif (DBG_IT == 35)
#elif (DBG_IT == 36)
#elif (DBG_IT == 37)
#elif (DBG_IT == 38)
#elif (DBG_IT == 39)
#elif (DBG_IT == 40)
#elif (DBG_IT == 41)
#elif (DBG_IT == 42)
#elif (DBG_IT == 43)
#endif
	{
		for(;;)
		{
			slCntr++;
			_en2log(slCntr);
		}
	}

}