demo.cpp

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

    if ((_Control.iGmode & 0x8) == 0)
    {
#define plt_s(n)\
        cline(x,YS0+(n)*4,x+DX,YS0+(n)*4,clr);\
        cline(x,YS0+(n)*4+1,x+DX,YS0+(n)*4+1,clr)
#define plt_ss(n)\
        cline(x,YS0+(n)*4+1,x+DX,YS0+(n)*4+1,clr);
    // prepare
        bar(x+1,YS0,x+DX*4,YS0+80);
        cline(x+DX+1, YS0, x+DX+1, YS0+80, LIGHTRED);
    // draw
        if (iStateChange) 
            cline(x,  YS0, x, YS0+80, DARKGRAY);
        if(pSc->sTestFailed & 0x0001) clr=RED;   else clr=WHITE;       plt_s(0);
        if(pSc->sTestFailed & 0x0002) clr=BLACK; else clr=CYAN;        plt_s(1);
        if(pSc->sTestFailed & 0x0004) clr=BLACK; else clr=LIGHTMAGENTA;plt_s(2);
        if(pSc->sTestFailed & 0x0008) clr=BLACK; else clr=MAGENTA;     plt_s(3);
                                                  clr=DARKGRAY;    plt_ss(4);
                                                  
        if(pSc->sTestFailed & 0x0010) clr=BLACK; else clr=RED;         plt_s(5);
        if(pSc->sTestFailed & 0x0020) clr=BLACK; else clr=BLUE;        plt_s(6);
        if(pSc->sTestFailed & 0x0040) clr=BLACK; else clr=YELLOW;      plt_s(7);
        if(pSc->sTestFailed & 0x0080) clr=BLACK; else clr=LIGHTCYAN;   plt_s(8);
                                                  clr=DARKGRAY;    plt_ss(9);

        if(pSc->sTestFailed & 0x0100) clr=BLACK; else clr=RED;         plt_s(10);
        if(pSc->sTestFailed & 0x0200) clr=BLACK; else clr=BLUE;        plt_s(11);
        if(pSc->sTestFailed & 0x0400) clr=BLACK; else clr=WHITE;       plt_s(12);
        if(pSc->sTestFailed & 0x0800) clr=BLACK; else clr=CYAN;        plt_s(13);

                                                  clr=DARKGRAY;    plt_ss(14);
        if(pSc->sTestFailed & 0x1000) clr=BLACK; else clr=LIGHTGREEN;  plt_s(15);
        if(pSc->sTestFailed & 0x2000) clr=BLACK; else clr=GREEN;       plt_s(16);
                                                  clr=DARKGRAY;    plt_ss(17);
        {
            switch(pDb->v.sState)
            {
            case CPD_ST_IDLE:     clr=BLACK;break;
            case CPD_ST_MAYBE:    clr=LIGHTBLUE;break;
            case CPD_ST_TONE:     clr=LIGHTGREEN;break;
            case CPD_ST_GOOD_TONE:clr=WHITE;break;
            case CPD_ST_ABORT:    clr=LIGHTRED;break;
            default:                clr=YELLOW;break;
            }

            plt_s(18);
        }
//                                                  clr=DARKGRAY;    plt_ss(15);
    }

    /* row 0 --------------------------------------------- */
    {
        int run = 0;
        static long cnt;
        static double __dSpeed = 0; 
        static unsigned long __ulTime = 0;

        if (_Control.iGmode & 0x10)
        {
            if (_uIsSeriaOver)
            {
                unsigned long ulTime = timeGetTime();
                __dSpeed = (6.0*cnt)/(ulTime - __ulTime);
                __ulTime = ulTime;
                run = 1;
                cnt = 0;
            }
            else
            {
                cnt++;
            }
            _uIsSeriaOver = FALSE;
        }
        else
        {
            run = 1;
        }

        if (run)
        {
            bar(XT0, YT0, XTM, YT0+YTD);
            val_out(XT0, YT0, GREEN,      "Frame  %ld", _Frame);
            val_out(XT1, YT0, GREEN,      "Time,s %6.2f", _Frame*0.005);
            val_out(XT2, YT0, GREEN,      "Speed %8.2f", __dSpeed);
            val_out(XT3, YT0, BROWN,      "catch %5d", _Control.iCatchCntr);
            val_out(XT4, YT0, LIGHTRED,   "GLo  %d", _Gen.sFLo);
            val_out(XT5, YT0, LIGHTBLUE,  "GHi  %d", _Gen.sFHi);
            val_out(XT6, YT0, RED,        "GLoF %6.2fHz", _Gen.fLoDev);
            val_out(XT7, YT0, BLUE,       "GHiF %6.2fHz", _Gen.fHiDev);
            val_out(XT8, YT0, WHITE,      "Hits %d",  _Stat.sLastStart); 
        }
    }

    if ((_Control.iGmode & 0x10) == 0)
    {
        /* row 1 --------------------------------------------- */
        bar(XT0, YT1, XTM, YT1+YTD);
        {
            extern S16 DBG_sFrameEn;
            val_out(XT0, YT1, LIGHTGREEN, "GState %d", _TgDb.sState);
            val_out(XT1, YT1, LIGHTRED,   "GLoAmp %d", _TgDb.Lo.sAmp);
            val_out(XT2, YT1, LIGHTBLUE,  "GHiAmp %d", _TgDb.Hi.sAmp);
            val_out(XT3, YT1, WHITE,      "Gsame  %d", _Gen.iSameCntr);
	        val_out(XT4, YT1, LIGHTRED,   "GLoIdx %d", _Gen.iLoIdx);
	        val_out(XT5, YT1, LIGHTBLUE,  "GHiIdx %d", _Gen.iHiIdx);
            val_out(XT6, YT1, LIGHTRED,   "GLoPh  %d", _TgDb.Lo.sPhase);
            val_out(XT7, YT1, LIGHTBLUE,  "GHiPh  %d", _TgDb.Hi.sPhase);
        }

        /* row 2 --------------------------------------------- */
        bar(XT0, YT2, XTM, YT2+YTD);
        {
            val_out(XT1, YT2, LIGHTGRAY,  "GtoneC %d", _Gen.iToneCntr);
            val_out(XT2, YT2, LIGHTGRAY,  "GfreqC %d", _Gen.iFreqCntr);
            val_out(XT3, YT2, LIGHTRED,   "GLoStp %d", _TgDb.Lo.sFreq);
            val_out(XT4, YT2, LIGHTBLUE,  "GHiStp %d", _TgDb.Hi.sFreq);
#if 0
            extern S16 _asMask[];
            val_out(XT5, YT2, WHITE,      "aMsk0  %x", _asMask[0]);
            val_out(XT6, YT2, WHITE,      "aMsk1  %x", _asMask[1]);
            val_out(XT7, YT2, WHITE,      "aMsk2  %x", _asMask[2]);
            val_out(XT8, YT2, WHITE,      "aMsk4  %x", _asMask[4]);
#endif
        }
        /* row 3 --------------------------------------------- */
        bar(XT0, YT3, XTM, YT3+YTD);
        {
            val_out(XT0, YT3, LIGHTGREEN, "DState %d", pDb->v.sState);
            val_out(XT1, YT3, LIGHTCYAN,  "DSts   %X", (~pSc->sTestFailed)&0xffff);

	        /* update low freq component */
            if((pSc->sTestFailed & 0x7ff5)==0)
	        {
		        val_out(XT2,YT3, LIGHTRED,"DTone  %d", pSc->sDigit);
	        }
	        else
	        {
		        val_out(XT2,YT3, WHITE,   "DTone  %d", pSc->sDigit);
	        }

            val_out(XT3, YT3, BLUE,       "DCntr  %d", pDb->v.sFrCntr);
            val_out(XT4, YT3, WHITE,      "DClean %8.2f",
                (cpd_en2log(pSc->aOut[pSc->sNextIdx].slEn,0) - 
                 cpd_en2log(pSc->aOut[pSc->sRestIdx].slEn,0))/170.1);

            val_out(XT5, YT3, RED,        "Cp %d", pSc->Lo.sCpred);
            val_out(XT6, YT3, GREEN,      "Sp %d", pSc->Lo.sSpred);
            val_out(XT7, YT3, LIGHTGREEN, "Dsum   %8.2f", pSc->sSumEn/170.1);
            val_out(XT8, YT3, WHITE,      "dTwstM %8.2f", 
                (cpd_en2log(pSc->aOut[pSc->sMaxIdx].slEn,0) - 
                 cpd_en2log(pSc->aOut[pSc->sNextIdx].slEn,0))/170.1);
        }
        /* row 4 --------------------------------------------- */
        bar(XT0, YT4, XTM, YT4+YTD);
        {
    	    for(k=0;k<CPD_FREQS;k++)
	        {
	    	    val_out(XT0+k*XTD, YT4, LIGHTGREEN, "En[%d] %8.2f", 
                    k, dbl(pDb->v.asSumEn[k]));
    	    }
            val_out(XT6, YT4, RED,        "LoIdx %d", pSc->sLoIdx);
            val_out(XT7, YT4, GREEN,      "HiIdx %d", pSc->sHiIdx);
            val_out(XT8, YT4, WHITE,      "ResIdx %d", pSc->sRestIdx);
        }
        /* row 5 --------------------------------------------- */
        bar(XT0, YT5, XTM, YT5+YTD);
        {
            val_out(XT4, YT5, RED,        "LoDi %7.2f", 
                (pSc->Lo.sEn - pSc->Lo.sDist)/170.1);
            val_out(XT5, YT5, GREEN,      "HiDi %7.2f",
                (pSc->Hi.sEn - pSc->Hi.sDist)/170.1);
            val_out(XT6, YT5, RED,        "LoEn %7.2f", pDb->Stts.sLoEn/170.1);
            val_out(XT7, YT5, GREEN,      "HiEn %7.2f", pDb->Stts.sHiEn/170.1);

        }
        /* row 6 --------------------------------------------- */
        bar(XT0, YT6, XTM, YT6+YTD);
        {
    	    for(k = 0; k < CPD_FREQS; k++)
	        {
                double C0 = pDb->aOutSav[k].sC;
                double S0 = pDb->aOutSav[k].sS;
                double C1 = pSc->aOut[k].sC;
                double S1 = pSc->aOut[k].sS;
                double a0 = atan2(S0, C0);
                double a1 = atan2(S1, C1);
                a1 =  (a1 - a0)/3.14259265;
	    	    val_out(XT0+k*XTD, YT6, _aiColor[k+2],"A[%d] %7.2f", 
                    k, a1);
    	    }
            val_out(XT6, YT6, RED,        "LoEr %7.2f", pDb->Stts.sLoErr/170.1);
            val_out(XT7, YT6, GREEN,      "HiEr %7.2f", pDb->Stts.sHiErr/170.1);
        }
    }
}

/*--------------------- public  functions ---------------------------------*/
/*-------------------------------------------------------------------------*/
void                    indicate_start
/*-------------------------------------------------------------------------*/
(
)
{
    _lStartFrame = _Frame;
}
/*-------------------------------------------------------------------------*/
void                    indicate_end
/*-------------------------------------------------------------------------*/
(
)
{
}

/*-------------------------------------------------------------------------*/
void                    dump_val
/*-------------------------------------------------------------------------*/
(
S16 s1, 
S16 s2
)
{
    if(_Control.pTmpFile)
        fprintf(_Control.pTmpFile, "%6d %6d\n", s1, s2);
}
/*-------------------------------------------------------------------------*/
int                     demo_ind_tone
/*-------------------------------------------------------------------------*/
(
S16 toneId,
S16 IsOn
)
{
    if (IsOn) // start
    {
        _Stat.sStart++;
        if (_Control.iCatchCntr > 0)
        {
            _Control.iCatchCntr = -1;
        }

        if (_Control.pDbgFile)
        {
            static int cntr = 0;
            cntr++;
            fprintf(_Control.pDbgFile, 
                "start    %2d [%05d] frame %ld\n",
                toneId,    cntr,  _Frame);
        }
    }
    else
    {
        _Stat.sEnd++;
        if (_Control.pDbgFile)
        {
            static int cntr = 0;
            cntr++;
            fprintf(_Control.pDbgFile, 
                "end      %2d [%05d] frame %ld\n",
                toneId,    cntr,  _Frame);
        }
    }
    return 0;
}

/*-------------------------------------------------------------------------*/
int                     demo_ind_abort
/*-------------------------------------------------------------------------*/
(
S16 toneId,
S16 IsOn
)
{
    _Stat.sAbort++;
    if (_Control.pDbgFile)
    {
        static int cntr = 0;
        cntr++;
        fprintf(_Control.pDbgFile, 
                "abort    %2d [%05d] frame %ld\n",
            toneId,    cntr,  _Frame);
    }
    return 0;
}

/*-------------------------------------------------------------------------*/
void                    demo_init
/*-------------------------------------------------------------------------*/
(
int Err
)
{
    if(fabs(_Control.fRxCorr) < 0.001)
            _Control.fRxCorr = 1.0;

    TG_init(&_TgDb);
    tg_config();
    TG_init(&_RevDb);
    rev_config();

    CPD_MIKET_init_db(&_CpdDb, (ICPD_tCfg *)&ICPD_MIKET_DefaultCfg);
    _CPD_Status.pCfg = &_CpdCfg;
    CPD_MIKET_control(&_CpdDb, 
                    ICPD_CMD_CFG | ICPD_CMD_RESET, 
                    &_CPD_Status);

    
    graphic_init(Err);
}

/*-------------------------------------------------------------------------*/
void                        demo_run
/*-------------------------------------------------------------------------*/
(
)
{
    S16 sRc;
    S16 k;

    _Frame++;

//    if(_Frame == 1780) DEMO_StepMode = TRUE;
//    if(_Frame == 5963) DEMO_StepMode = TRUE;
//    if(_Frame == 6624) DEMO_StepMode = TRUE;

    for(k=0; k < RX_DELAY; k++) _aRx[k] = _aRx[k+ICPD_FR_SZ];
	fill_input(&_aRx[RX_DELAY]);

	sRc = CPD_MIKET_process(&_CpdDb, &_CpdSc, &_aRx[0]);
//    for(k=0; k < ICPD_FR_SZ; k++) dump_val(_aRx[k],0);

    switch(sRc&0xff00)
    {
    case ICPD_EV_NONE:
        break;
    case ICPD_EV_START:
        demo_ind_tone (sRc & 0xff, TRUE);
        break;
    case ICPD_EV_END:
        demo_ind_tone (sRc & 0xff, FALSE);
        dump_val(_CpdDb.Stts.sLoErr, _CpdDb.Stts.sHiErr);
        break;
    case ICPD_EV_ABORT:
        demo_ind_abort(sRc & 0xff, TRUE);
//        DEMO_StepMode = TRUE;
        break;
    }

    if (--_Control.iCatchCntr == 0)
    {
        if ((_Control.iCatch) && (_Gen.iSameCntr < _Gen.iSameCntrMax))

        {
            DEMO_StepMode = TRUE;
        }
    }

	plot_results();
}

/*-------------------------------------------------------------------------*/
void                    demo_exit
/*-------------------------------------------------------------------------*/
(
)
{
	// close all files
	if (_Control.pDbgFile) fclose(_Control.pDbgFile);
	if (_Control.pInFile)  fclose(_Control.pInFile);
	if (_Control.pOutFile) fclose(_Control.pOutFile);
	if (_Control.pTmpFile) fclose(_Control.pTmpFile);
}

/*-------------------------------------------------------------------------*/
int                     demo_get_cfg
/*-------------------------------------------------------------------------*/
(
)
{
    int Err = 0;
	FILE *pCfgFile = fopen("sim.cfg", "r");
    int Line;

	if ( pCfgFile == NULL )
	{
        Err = 99;
		_err(Err, 0, "opening config file SIM.CFG ");
	}
	else
	{
		for ( Line = 1;; Line++)
		{
			int i;
			char *p = fgets(_aBuff, 80, pCfgFile);
			if ( p == NULL )	// EOF
			{
				break;
			} /* end-of-if */
			for ( i = 0; i < 80; i++ )
			{
				if ( iscntrl(_aBuff[i]))
				{
					_aBuff[i] = 0;
					break;
				} /* end-of-if */
			}  /* end-of-for */

			if (strlen(_aBuff))
			{
				Err = get_cfg_line(_aBuff);
				if(Err)
				{
                    _err(Err, Line, " processing sim.cfg file at ");
                    val_out(330, 20, WHITE,      "%s", _aBuff);

					break;
				}
			}
		}  /* end-of-for */
		fclose(pCfgFile);
	}
    return Err;
}