demo.cpp

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

        cline(x-3*DX,YS0+(n)*4+1,x+DX,YS0+(n)*4+1,clr);
    // prepare
        bar(x+1,YS0,x+DX*8,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->Cas.sTest & 0x0001) clr=BLACK; else clr=LIGHTRED;   plt_s(0);
        if(pSc->Cas.sTest & 0x0002) clr=BLACK; else clr=RED;        plt_s(1);
        if(pSc->Cas.sTest & 0x0004) clr=BLACK; else clr=YELLOW;     plt_s(2);
        if(pSc->Cas.sTest & 0x0008) clr=BLACK; else clr=GREEN;      plt_s(3);
                                                  clr=DARKGRAY;    plt_ss(4);
                                                  
        if(pSc->Cas.sTest & 0x0010) clr=BLACK; else clr=LIGHTCYAN;  plt_s(5);
        if(pSc->Cas.sTest & 0x0020) clr=BLACK; else clr=CYAN;       plt_s(6);
        if(pSc->Cas.sTest & 0x0040) clr=BLACK; else clr=LIGHTBLUE;  plt_s(7);
                                                  clr=DARKGRAY;    plt_ss(8);
        if(!(pDb->uCasReg & 0x0001)) clr=BLACK; else clr=MAGENTA;      plt_s(9);
        if(!(pDb->uCasReg & 0x0002)) clr=BLACK; else clr=MAGENTA;      plt_s(10);
        if(!(pDb->uCasReg & 0x0004)) clr=BLACK; else clr=MAGENTA;      plt_s(11);
        if(!(pDb->uCasReg & 0x0008)) clr=BLACK; else clr=MAGENTA;      plt_s(12);
                                                  clr=DARKGRAY;    plt_ss(13);
        if(!(pDb->uCasReg & 0x0010)) clr=BLACK; else clr=MAGENTA;      plt_s(14);
        if(!(pDb->uCasReg & 0x0020)) clr=BLACK; else clr=MAGENTA;      plt_s(15);
        if(!(pDb->uCasReg & 0x0040)) clr=BLACK; else clr=MAGENTA;      plt_s(16);
        if(!(pDb->uCasReg & 0x0080)) clr=BLACK; else clr=MAGENTA;      plt_s(17);
                                                  clr=DARKGRAY;    plt_ss(18);
        {
            switch(pDb->sState)
            {
            case 0:clr=BLACK;break;
            case 1:clr=LIGHTBLUE;break;
            case 2:clr=WHITE;break;
            case 3:clr=LIGHTGREEN;break;
            case 4:clr=LIGHTCYAN;break;
            case 5:clr=LIGHTRED;break;
            default:clr=RED;break;
            }

            plt_s(18);
        }
                                                  clr=DARKGRAY;    plt_ss(19);
    }
    /* row 0 --------------------------------------------- */
    {
        int run = 0;
        static double __dSpeed = 0; 
        static unsigned long __ulTime = 0;

        if ((_Frame%200) == 0) // once a second
        {
            unsigned long ulTime = timeGetTime();
            __dSpeed = (1000.0)/(ulTime - __ulTime);
            __ulTime = ulTime;
            run = 1;
        }

        if (((_Control.iGmode & 0x4) == 0) || 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, LIGHTRED,   "Errs %d",  _Stat.sErrs); 
            val_out(XT4, YT0, LIGHTBLUE,  "Bytes %ld", _Stat.lBytes); 
            val_out(XT5, YT0, LIGHTCYAN,  "Errs %7.4f%%",  100.*_Stat.sErrs/(double)(_Stat.lBytes)); 
            val_out(XT6, YT0, LIGHTRED,   "Aborts %d",  pDb->Stts.sAbort); 
            val_out(XT7, YT0, WHITE,      "Ends   %d", pDb->Stts.sEnd);
            val_out(XT8, YT0, BROWN,      "Same %5d", _Gen.iSame);
        }
    }

    if ((_Control.iGmode & 0x8) == 0)
    {
        /* row 1 --------------------------------------------- */
        bar(XT0, YT1, XTM, YT1+YTD);
        {
            extern S16 DBG_sFrameEn;
            val_out(XT0, YT1, LIGHTGREEN, "GState %d", _Gen.iState);
            val_out(XT1, YT1, WHITE,      "Gsame  %d", _Gen.iSame);
            val_out(XT2, YT1, LIGHTRED,   "Norm  %8.2f", 1./Norm);
            val_out(XT3, YT1, CYAN,       "FLo   %8.2f",4000.*_TgCfg.Lo.sFreq/32768.);
            val_out(XT4, YT1, CYAN,       "FHi   %8.2f",4000.*_TgCfg.Hi.sFreq/32768.);
            val_out(XT5, YT1, RED,        "LoIdx  %d", _Gen.iLoIdx);
            val_out(XT6, YT1, LIGHTRED,   "LoDev%% %8.2f", _Gen.fLoDev*100.);
            val_out(XT7, YT1, CYAN,       "HiIdx  %d", _Gen.iHiIdx);
            val_out(XT8, YT1, LIGHTCYAN,  "HiDev%% %8.2f", _Gen.fHiDev*100.);
        }

        /* row 2 --------------------------------------------- */
        bar(XT0, YT2, XTM, YT2+YTD);
        {
            val_out(XT1, YT2, LIGHTBLUE,  "GChar  %d", _Gen.iChar);
            val_out(XT5, YT2, GREEN,      "GBit  %d", _Gen.iBitNo);
            val_out(XT6, YT2, LIGHTBLUE,  "GByte  %d", _Gen.iByteNo);
            val_out(XT8, YT2, LIGHTBLUE,  "GSC  %d", _Gen.iCS);
        }
        /* row 3 --------------------------------------------- */
        bar(XT0, YT3, XTM, YT3+YTD);
        {
            val_out(XT0, YT3, LIGHTGREEN, "DState %d", pDb->sState);
            val_out(XT1, YT3, LIGHTGREEN, "DOn    %d", pDb->sIsOn);
            val_out(XT2, YT3, WHITE, "DAlign %d", pDb->sAlignment);
            val_out(XT3, YT3, RED, "DStart %d", pDb->sStart);
            val_out(XT4, YT3, YELLOW, "DBitLn %d", pDb->sCurrBitLen);
            val_out(XT5, YT3, GREEN, "DBits  %d", pDb->sBits);
            val_out(XT6, YT3, LIGHTBLUE, "DBytes %d", pDb->sBytes);
            val_out(XT7, YT3, LIGHTGREEN, "DLen   %d", pDb->sLen);
            val_out(XT8, YT3, LIGHTBLUE, "DCS    %d", pDb->sCheckSum&0xff);

        }
        /* row 4 --------------------------------------------- */
        bar(XT0, YT4, XTM, YT4+YTD);
        {
            extern S16 asOffsets[10];
            val_out(XT0, YT4, LIGHTGRAY, "DAverg %d", pSc->sAverage);

            val_out(XT3, YT4, WHITE,     "Deven  %d", pDb->sEven);
            val_out(XT4, YT4, WHITE,     "Do-2   %d", pSc->asOut[asOffsets[0]-2]);
            val_out(XT5, YT4, WHITE,     "Do-1   %d", pSc->asOut[asOffsets[0]-1]);
            val_out(XT6, YT4, WHITE,     "D0     %d", pSc->asOut[asOffsets[0]]);
            val_out(XT7, YT4, WHITE,     "Do+1   %d", pSc->asOut[asOffsets[0]+1]);
            val_out(XT8, YT4, WHITE,     "Do+2   %d", pSc->asOut[asOffsets[0]+2]);

        }
        /* row 5 --------------------------------------------- */
        bar(XT0, YT5, XTM, YT5+YTD);
        {
            extern S16 asOffsets[10];
            val_out(XT0, YT5, LIGHTGRAY, "Dsm0   %d", pSc->asSum[0]);
            val_out(XT1, YT5, LIGHTGRAY, "Dsm1   %d", pSc->asSum[1]);
            val_out(XT2, YT5, LIGHTGRAY, "Dsm2   %d", pSc->asSum[2]);
            val_out(XT3, YT5, LIGHTGRAY, "Dsm3   %d", pSc->asSum[3]);
            val_out(XT4, YT5, LIGHTGRAY, "Dsm4   %d", pSc->asSum[4]);
            val_out(XT6, YT5, WHITE,     "Dshft  %d", _sShift);
            val_out(XT8, YT5, LIGHTGRAY, "DOff0  %d", asOffsets[0]);
        }
        /* row 6 --------------------------------------------- */
        bar(XT0, YT6, XTM, YT6+YTD);
        {
            val_out(XT0, YT6, LIGHTGRAY, "Shft0 %ld", __aslShiftCntr[0]);
            val_out(XT1, YT6, LIGHTGRAY, "Shft1 %ld", __aslShiftCntr[1]);
            val_out(XT2, YT6, LIGHTGRAY, "Shft2 %ld", __aslShiftCntr[2]);
            val_out(XT3, YT6, LIGHTGRAY, "Shft3 %ld", __aslShiftCntr[3]);
            val_out(XT4, YT6, LIGHTGRAY, "Shft4 %ld", __aslShiftCntr[4]);

            val_out(XT6, YT6, LIGHTCYAN, "ShfReg %x", (pDb->uCasReg)&0xffff);
        }
        /* row 7 --------------------------------------------- */
        bar(XT0, YT7, XTM, YT7+YTD);
        {
            CLID_tCasDb *pCasDb = (CLID_tCasDb *)pDb;
            int idx = ((pDb->sCasIdx - 1) & 3) + CLID_CAS_FD_SSZ;
            val_out(XT0, YT7, LIGHTGRAY, "CasIdx %d", pDb->sCasIdx);
            val_out(XT1, YT7, BROWN,     "CasLoI %d", pCasDb->asLoI[idx]);
            val_out(XT2, YT7, RED,       "CasLoQ %d", pCasDb->asLoQ[idx]);
            val_out(XT3, YT7, MAGENTA,   "CasHiI %d", pCasDb->asHiI[idx]);
            val_out(XT4, YT7, CYAN,      "CasHiQ %d", pCasDb->asHiQ[idx]);
            if (pDb->sCasIdx==0)
            {
            val_out(XT5, YT7, LIGHTRED,  "LoEn   %7.2f", pSc->Cas.sLoEn/170.);
            val_out(XT6, YT7, RED,       "LoFr   %7.2f", pSc->Cas.sLoFreq/170.);
            val_out(XT7, YT7, LIGHTCYAN, "HiEn   %7.2f", pSc->Cas.sHiEn/170.);
            val_out(XT8, YT7, CYAN,      "HiFr   %7.2f", pSc->Cas.sHiFreq/170.);
            }
        }
        bar(XT0, YT8, XTM, YT8+YTD);
        if (pDb->sCasIdx==0)
        {
            val_out(XT0, YT8, LIGHTGRAY, "LoIC1 %d", pSc->Cas.sLoIC1);
            val_out(XT1, YT8, LIGHTGRAY, "LoIS1 %d", pSc->Cas.sLoIS1);
            val_out(XT2, YT8, LIGHTGRAY, "LoQC1 %d", pSc->Cas.sLoQC1);
            val_out(XT3, YT8, LIGHTGRAY, "LoQS1 %d", pSc->Cas.sLoQS1);
            val_out(XT4, YT8, LIGHTGRAY, "LoIC2 %d", pSc->Cas.sLoIC2);
            val_out(XT5, YT8, LIGHTGRAY, "LoIS2 %d", pSc->Cas.sLoIS2);
            val_out(XT6, YT8, LIGHTGRAY, "LoQC2 %d", pSc->Cas.sLoQC2);
            val_out(XT7, YT8, LIGHTGRAY, "LoQS2 %d", pSc->Cas.sLoQS2);
        }
    }
}
/*-------------------------------------------------------------------------*/
void                    clid_compare
/*-------------------------------------------------------------------------*/
(
S16 sBytes, 
U16 uByte
)
{
    int x = 5+27 * (sBytes % 40);
    int y = 2+45 * (sBytes / 40);
    if ((uByte & 0xff) != (_Gen.aMsg[sBytes] & 0xff))
    {
        if ((_Control.iGmode & 0x10) == 0)
        {
            bar(x,y,x+50,y+44);
            cline(x+29,y, x+29, y+44, LIGHTRED);
            val_out(x, y,    LIGHTRED, " %02X", (uByte & 0xff));
            val_out(x, y+20, LIGHTRED, " %02X", (_Gen.aMsg[sBytes]&0xff));
        }
        _Stat.sErrs++;
//        DEMO_StepMode = TRUE;
    }
    else
    {
        if ((_Control.iGmode & 0x10) == 0)
        {
            bar(x,y,x+50,y+44);
            cline(x+29,y, x+29, y+44, LIGHTRED);
            val_out(x, y,    LIGHTGREEN, " %02X", (uByte & 0xff));
            val_out(x, y+20, LIGHTGREEN, " %02X", (_Gen.aMsg[sBytes]&0xff));
        }
        _Stat.lBytes++;
//        DEMO_StepMode = TRUE;
    }
}
/*--------------------- public  functions ---------------------------------*/

/*-------------------------------------------------------------------------*/
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;
}
/*-------------------------------------------------------------------------*/
int                     demo_ind_cas
/*-------------------------------------------------------------------------*/
(
S16 toneId,
S16 IsOn
)
{
    _Stat.sCas++;
    if (_Control.pDbgFile)
    {
        static int cntr = 0;
        cntr++;
        fprintf(_Control.pDbgFile, 
                "cas    [%05d] frame %ld\n",
                 cntr,  _Frame);
    }
    return 0;
}

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

    _init_gen_clid();
#if (_CAS_MODE == 4)
    _add_config();
#endif
    if (_Control.pFltFile == NULL) 
    {
        if (_afRxFlt[0] == 0)
        {
            _afRxFlt[0] = 1.0;
        }
    }

    CLID_MIKET_init_db(&_ClidDb, &_ClidCfg);
    memcpy(&_ClidStatus.Cfg, &ICLID_MIKET_DefaultCfg, sizeof(ICLID_tCfg));

    switch (_Gen.sMode) 
    {
    case 1:
        CLID_MIKET_control(&_ClidDb, 
                    ICLID_CMD_CFG | ICLID_CMD_RESET | ICLID_CMD_TYPE1, 
                    &_ClidStatus);
        break;
    case 2:
        CLID_MIKET_control(&_ClidDb, 
                    ICLID_CMD_CFG | ICLID_CMD_RESET | ICLID_CMD_TYPE2, 
                    &_ClidStatus);
        break;
    case 3:
        CLID_MIKET_control(&_ClidDb, 
                    ICLID_CMD_CFG | ICLID_CMD_RESET | ICLID_CMD_CAS, 
                    &_ClidStatus);
        break;
    }
    
    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+ICLID_FR_SZ];
	fill_input(&_aRx[RX_DELAY]);

	sRc = CLID_MIKET_process(&_ClidDb, &_ClidSc, &_aRx[0]);
    for(k=0; k < ICLID_FR_SZ; k++) dump_val(_aRx[k],0);

    switch(sRc&0xff00)
    {
    case ICLID_EV_NONE:
        break;
    case ICLID_EV_START:
        demo_ind_tone (sRc & 0xff, TRUE);
        break;
    case ICLID_EV_END:
//        DEMO_StepMode = TRUE;
        CLID_MIKET_control(&_ClidDb, ICLID_CMD_RESET | ICLID_CMD_TYPE1, &_ClidStatus);
        demo_ind_tone (sRc & 0xff, FALSE);
        break;
    case ICLID_EV_ABORT:
        CLID_MIKET_control(&_ClidDb, ICLID_CMD_RESET | ICLID_CMD_TYPE1, &_ClidStatus);
        demo_ind_abort(sRc & 0xff, TRUE);
//        DEMO_StepMode = TRUE;
        break;
    case ICLID_EV_CAS:
        CLID_MIKET_control(&_ClidDb, ICLID_CMD_RESET | ICLID_CMD_CAS, &_ClidStatus);
        demo_ind_cas(sRc & 0xff, TRUE);
//        DEMO_StepMode = TRUE;
        break;
    }

    if (--_Control.iCatchCntr == 0)
    {
        if ((_Control.iCatch) && (_Gen.iSame < _Gen.iSameMax))

        {
            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;
}
void indicate_start(){}
void indicate_end(){}

#if 0
            long x= 0x1234567;
#define CK (0.56789)
            S16 ck = (S16)(CK * 0x8000L);
            long ac0 = x;
            long ac2 = ((ac0 & 0xffff) * ck)<<1;
            ac2 >>= 16;
            ac0 >>= 16;
            ac2 += (ac0 * ck)<<1;
            val_out(XT7, YT6, WHITE,      "%lx", ac2);
            val_out(XT8, YT6, WHITE,      "%lx", long(x*CK));
            val_out(XT6, YT6, WHITE,      "%8.4f", 100*(x*CK-ac2)/(x*CK));
#endif