demo.cpp

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

			{
                Rc = 2;
			}
            else
            {
				_Gen.iMarks = iTmp*20;
            }
		}
        else if (str_cmp("BYTES", &pArg) == 0)
		{
			if (sscanf(pArg, "%d", &iTmp) != 1)
			{
                Rc = 2;
			}
            else
            {
				_Gen.iBytes = iTmp % 253;
            }
		}
        else if (str_cmp("DNORMSHIFT", &pArg) == 0)
		{
			if (sscanf(pArg, "%d", &iTmp) != 1)
			{
                Rc = 2;
			}
            else
            {
				_ClidCfg.sNormShift = S16(iTmp);
            }
		}
        else if (str_cmp("MODE", &pArg) == 0)
		{
			if (sscanf(pArg, "%d", &iTmp) != 1)
			{
                Rc = 2;
			}
            else
            {
				_Gen.sMode = iTmp;
            }
		}
        else if (str_cmp("FREQDEV", &pArg) == 0)
		{
			if (sscanf(pArg, "%f", &Tmp) != 1)
			{
                Rc = 2;
			}
            else
            {
				_Gen.fFreqDev = Tmp/100.0;
            }
		}
        else if (str_cmp("FREQSTEPS", &pArg) == 0)
		{
			if (sscanf(pArg, "%d", &iTmp) != 1)
			{
                Rc = 2;
			}
            else
            {
				_Gen.iFreqSteps = iTmp;
            }
		}
        else if (str_cmp("LOLEVEL", &pArg) == 0)
		{
			if (sscanf(pArg, "%f", &Tmp) != 1)
			{
                Rc = 2;
			}
            else
            {
				_Gen.fRxLoLevel = LEV0 * pow (10.0, Tmp/20.0) * 1.41;
            }
		}
        else if (str_cmp("HILEVEL", &pArg) == 0)
		{
			if (sscanf(pArg, "%f", &Tmp) != 1)
			{
                Rc = 2;
			}
            else
            {
				_Gen.fRxHiLevel = LEV0 * pow (10.0, Tmp/20.0) * 1.41;
            }
		}
        else if (str_cmp("PRESILENCE", &pArg) == 0)
		{
			if (sscanf(pArg, "%d", &iTmp) != 1)
			{
                Rc = 2;
			}
            else
            {
				_Gen.iPreSilenceDuration = iTmp;
            }
		}
        else if (str_cmp("POSTSILENCE", &pArg) == 0)
		{
			if (sscanf(pArg, "%d", &iTmp) != 1)
			{
                Rc = 2;
			}
            else
            {
				_Gen.iPostSilenceDuration = iTmp;
            }
		}
        else if (str_cmp("SIGNALDUR", &pArg) == 0)
		{
			if (sscanf(pArg, "%d", &iTmp) != 1)
			{
                Rc = 2;
			}
            else
            {
				_Gen.iSignalDuration = iTmp;
            }
		}
        else
	    {
		    Rc = 3;
	    }
    } /* end of if */
    else
    {
        // that's a comment
    }
    return Rc;
}

/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/

/*                  O U T P U T                                            */

/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/


/*-------------------------------------------------------------------------*/
void                        dump_results
/*-------------------------------------------------------------------------*/
(
)
{
    if (_Control.pOutFile != NULL)
    {
#if 0
        fprintf(_Control.pOutFile, 
            "F1=%4d[%4.1f]; F2=%4d[%4.1f]: end=%3d; start=%3d; abort=%3d\n", 
            _Gen.sFLo,
            _Gen.fLoDev*100.,
            _Gen.sFHi,
            _Gen.fHiDev*100.,
            _Stat.sEnd,
            _Stat.sStart,
            _Stat.sAbort
            );
#else
#if 0
        fprintf(_Control.pOutFile, 
            "%5d %5d %5d\n", 
            _Stat.sEnd,
            _Stat.sStart,
            _Stat.sAbort
            );
#else
        fprintf(_Control.pOutFile, "%5d\n", _Stat.sCas);
#endif
#endif
    }
    _Stat.sLastStart = _Stat.sStart;
    _Stat.sEnd = 0;
    _Stat.sStart = 0;
    _Stat.sAbort = 0;
    _Stat.sCas = 0;
}


/* ------------------------------------------------------------------- */
void                    graphic_init
/* ------------------------------------------------------------------- */
(
int Err
)
{
    val_out(XT6, YT0, WHITE, "ERR %d", Err);
    val_out(XT7, YT0, WHITE, "delay %6.2f", _Control.fDelay);

    val_out(XT0, YT1, LIGHTRED, "Silence %d", _Gen.iSilence);
    val_out(XT0, YT2, LIGHTRED, "Seizure %d", _Gen.iSeizure);
    val_out(XT0, YT3, LIGHTRED, "Marks   %d", _Gen.iMarks);
    val_out(XT0, YT4, LIGHTRED, "Bytes   %d", _Gen.iBytes);

    val_out(XT2, YT3, LIGHTCYAN, "SameMax %d", _Gen.iSameMax);

    val_out(XT4, YT1, WHITE, "dbg file: %p", _Control.pDbgFile);
    val_out(XT4, YT2, WHITE, "in file : %p", _Control.pInFile);
    val_out(XT4, YT3, WHITE, "out file: %p", _Control.pOutFile);


    val_out(XT6, YT1, LIGHTGREEN, "RxHi %d", _Gen.iRxLevel);
    val_out(XT6, YT2, LIGHTGREEN, "RxNo %d", _Gen.iRxNoise);
    val_out(XT6, YT3, GREEN, "DF1 %7.2f", _Gen.fDf1);
    val_out(XT6, YT4, GREEN, "DF2 %7.2f", _Gen.fDf2);

}

/*-------------------------------------------------------------------------*/
void                    plt_x
/*-------------------------------------------------------------------------*/
(
int x, 
int dx, 
int y, 
S16 *pData, 
int Sz, 
double Norm, 
int color
)
{
    set_color(color);
    for (int k = 0; k < Sz; k++)
    {
        int d1 = int(pData[k-1]*Norm);
        int d0 = int(pData[k-0]*Norm);
        line(x, y-d1, x+dx, y-d0);
        x+= dx;
    }
}



/*-------------------------------------------------------------------------*/
double                  dbl
/*-------------------------------------------------------------------------*/
(
S16 in
)
{
    double en = in/170.1;
    if (en < YEDBMIN) en = YEDBMIN;
    if (en > YEDBMAX) en = YEDBMAX;
    return en;
}
/*-------------------------------------------------------------------------*/
void                    plot_results
/*-------------------------------------------------------------------------*/
(
)
{
    CLID_tDb *pDb = &_ClidDb;
    CLID_tSc *pSc = &_ClidSc;

	int k;
//    double afNew[10];
    int x;
//    int clr;

    static int sOldState = 0;
    int iStateChange = 0;
    static long __aslShiftCntr[5];
    extern S16 _sShift;
    double Norm = 0.5*YIA/(double(_Gen.iRxLevel*2)*2);
    
    if (pDb->sState != sOldState)
    {
        sOldState = pDb->sState;
        iStateChange = TRUE;
    }

    if ((_Gen.sMode==3) && ((_Control.iGmode & 0x20) == 0))
	{
        CLID_tCasDb *pCasDb = (CLID_tCasDb *)pDb;
        int k;
        int iMax = 0;
        for (k = 0; k < CLID_CAS_FD_ASZ; k++)
        {
            int x;
            x = abs(pCasDb->asLoI[k]); if (iMax<x)iMax=x;
            x = abs(pCasDb->asLoQ[k]); if (iMax<x)iMax=x;
            x = abs(pCasDb->asHiI[k]); if (iMax<x)iMax=x;
            x = abs(pCasDb->asHiQ[k]); if (iMax<x)iMax=x;
        }
        bar(0, 0, 5*CLID_CAS_FD_ASZ, 160);
        plt_x(0,5,  20, pCasDb->asLoI+1, CLID_CAS_FD_ASZ,20./iMax, BROWN);
        plt_x(0,5,  60, pCasDb->asLoQ+1, CLID_CAS_FD_ASZ,20./iMax, RED);
        plt_x(0,5, 100, pCasDb->asHiI+1, CLID_CAS_FD_ASZ,20./iMax, MAGENTA);
        plt_x(0,5, 140, pCasDb->asHiQ+1, CLID_CAS_FD_ASZ,20./iMax, CYAN);
    }
	/* plot curr packet */
    if ((_Control.iGmode & 0x1) == 0)
	{
        static S16 sBytes = 0;

#define DD8 (3)
#define DD6 (4)
#define FR_SZ (DD8*ICLID_FR_SZ)
        
		x = X0 + (_Frame%IFR_MAX) * FR_SZ;
// prepare
		bar(x+1, YI-YIA-2, x+FR_SZ+FR_SZ/4, YI+4*YIA+2);
        cline(x+FR_SZ+1, YI-YIA, x+FR_SZ+1, YI+4*YIA, LIGHTRED);
        cline(x+FR_SZ,   YI-YIA, x+FR_SZ,   YI+4*YIA, LIGHTGRAY); 

        for(k = 0; k < 11; k++)
        {
            cline(x, YI-YIA+k*YIA/2, x+FR_SZ, YI-YIA+k*YIA/2, LIGHTGRAY);
        }

        plt_x(x, DD8,  YI+YIA*0-YIA/2, &_aRx[1], ICLID_FR_SZ,Norm, LIGHTMAGENTA);
        plt_x(x, DD8,  YI+YIA*1-YIA/2, &pSc->asBp[CLID_BPF_SSZ],ICLID_FR_SZ,Norm, RED);
//        plt_x(x, DD8,  YI+YIA*1-YIA/2, &pSc->asLpR[0],ICLID_FR_SZ,Norm, LIGHTBLUE);

        plt_x(x, DD8,  YI+YIA*2-YIA/2, &pSc->asLpI[CLID_LPF_SSZ],ICLID_FR_SZ,Norm, CYAN);
        plt_x(x, DD8,  YI+YIA*2-YIA/2, &pSc->asLpQ[CLID_LPF_SSZ],ICLID_FR_SZ,Norm, BROWN);

        plt_x(x, DD6,  YI+YIA*3-YIA/2, &pSc->asMfI[CLID_MF_SSZ],CLID6_FR_SZ,Norm, LIGHTCYAN);
        plt_x(x, DD6,  YI+YIA*3-YIA/2, &pSc->asMfQ[CLID_MF_SSZ],CLID6_FR_SZ,Norm, YELLOW);

        plt_x(x, DD6,  YI+YIA*3+YIA/2, &pSc->asOut[CLID_OUT_SSZ],CLID6_FR_SZ,1./500, WHITE);

        if (sBytes != pDb->sBytes)
        {
            __aslShiftCntr[_sShift]++;
            extern S16 asOffsets[10];
            for (k = 0; k < 10; k++)
            {
                S16 xx = x + (asOffsets[k]-CLID_OUT_SSZ+1)*DD6;
                if (xx < X0) xx += IFR_MAX * FR_SZ;
                if (xx > X0 + IFR_MAX * FR_SZ) xx -= IFR_MAX * FR_SZ;

                if (k == 0)
                cline(xx, YI+YIA*3+YIA/2-10, xx, YI+YIA*3+YIA/2+10, LIGHTGREEN);
                else if (k == 9)
                cline(xx, YI+YIA*3+YIA/2-10, xx, YI+YIA*3+YIA/2+10, LIGHTMAGENTA);
                else
                cline(xx, YI+YIA*3+YIA/2-10, xx, YI+YIA*3+YIA/2+10, LIGHTCYAN);

                if ((k > 0) && (k < 9))
                {
                    S16 b = k-1;
                    U16 uByte;
                    int color = LIGHTCYAN;;

                    uByte = pDb->auByteStorage[sBytes/2];
                    if (sBytes & 1)
                        uByte >>= 8;
                    else
                        uByte &= 0xff;

                    if ((_Gen.aMsg[sBytes] ^ uByte) & (1<<b))
                        color = LIGHTRED;


                    if (_Gen.aMsg[sBytes] & (1<<(b)))
                    {
                        cline(xx-10, YI+YIA*3+YIA/2-10, xx+10, YI+YIA*3+YIA/2-10, color);
                    }
                    else
                    {
                        cline(xx-10, YI+YIA*3+YIA/2+10, xx+10, YI+YIA*3+YIA/2+10, color);
                    }
                }

            }
            sBytes = pDb->sBytes;
        }
	}

    x = X0 + (_Frame % EDFR_MAX)*DX;

	/* plot Energy for current Packet */
    if ((_Control.iGmode & 0x2) == 0)
    {
        int t;
// prepare for drawing
        bar(XE1, YE0-YEDBMAX*DBE2PX, XE1+100, YE0-YEDBMIN*DBE2PX);
        bar(x+1, YE0-YEDBMAX*DBE2PX, x+4*DX,  YE0-YEDBMIN*DBE2PX);
        cline(x+DX+1, YE0-YEDBMAX*DBE2PX, x+DX+1, YE0 - YEDBMIN*DBE2PX, LIGHTRED);

        if (iStateChange) 
            cline(x,YE0-YEDBMAX*DBE2PX, x, YE0 - YEDBMIN*DBE2PX, DARKGRAY);

        set_color(DARKGRAY);
        for (k = 0; k < -YEDBMIN/10+1; k++)
        {
            line(x+1,  YE0+DBE2PX*10*k,  x+DX, YE0+DBE2PX*10*k); 
            line(XE1,  YE0+DBE2PX*10*k,  XE1+100, YE0+DBE2PX*10*k); 
        }

        {
            static int Last = 0;
            t = int(-1000*pDb->sAlignment/32767.) + DBE2PX*10*3;
            cline(x, YE0 + Last, x+DX, YE0 + t, LIGHTRED);
            Last = t;
        }
        {
            static int Last = 0;
            t = int(-10000*pSc->sAverage/32767.) + DBE2PX*10*3;
            cline(x, YE0 + Last, x+DX, YE0 + t, LIGHTMAGENTA);
            Last = t;
        }

        {
            static int Last = 0;
            t = -pDb->sState * 30 + DBE2PX*10*6;
            cline(x, YE0 + Last, x+DX, YE0 + t, LIGHTGREEN);
            Last = t;
        }
        if (_Gen.sMode==3)
        {
        {
            static int Last = 0;
            int idx = ((pDb->sCasIdx - 1) & 3) + CLID_CAS_FD_SSZ;
            CLID_tCasDb *pCasDb = (CLID_tCasDb *)pDb;
            t = YE0 + 50 - (int)(pCasDb->asLoI[idx]*Norm);
            cline(x, Last, x+DX, t, BROWN);
            Last = t;
        }
        {
            static int Last = 0;
            int idx = ((pDb->sCasIdx - 1) & 3) + CLID_CAS_FD_SSZ;
            CLID_tCasDb *pCasDb = (CLID_tCasDb *)pDb;
            t = YE0 + 50 - (int)(pCasDb->asLoQ[idx]*Norm);
            cline(x, Last, x+DX, t, RED);
            Last = t;
        }
        {
            static int Last = 0;
            int idx = ((pDb->sCasIdx - 1) & 3) + CLID_CAS_FD_SSZ;
            CLID_tCasDb *pCasDb = (CLID_tCasDb *)pDb;
            t = YE0 + 80 - (int)(pCasDb->asHiI[idx]*Norm);
            cline(x, Last, x+DX, t, MAGENTA);
            Last = t;
        }
        {
            static int Last = 0;
            int idx = ((pDb->sCasIdx - 1) & 3) + CLID_CAS_FD_SSZ;
            CLID_tCasDb *pCasDb = (CLID_tCasDb *)pDb;
            t = YE0 + 80 - (int)(pCasDb->asHiQ[idx]*Norm);
            cline(x, Last, x+DX, t, CYAN);
            Last = t;
        }
        {
            static int Last = 0;
            if (pDb->sCasIdx == 0)
            {
                t = YE0 - int(DBE2PX*dbl(pSc->Cas.sLoEn));
                cline(x-3*DX, Last, x+DX, t, YELLOW);
                Last = t;
            }
        }
        {
            static int Last = 0;
            if (pDb->sCasIdx == 0)
            {
                t = YE0 - int(DBE2PX*dbl(pSc->Cas.sHiEn));
                cline(x-3*DX, Last, x+DX, t, LIGHTCYAN);
                Last = t;
            }
        }
        {
            static int Last = 0;
            if (pDb->sCasIdx == 0)
            {
                t = YE0+30- int(10*DBE2PX*dbl(pSc->Cas.sLoFreq));
                cline(x-3*DX, Last, x+DX, t, BROWN);
                Last = t;
            }
        }
        {
            static int Last = 0;
            if (pDb->sCasIdx == 0)
            {
                t = YE0+30 - int(10*DBE2PX*dbl(pSc->Cas.sHiFreq));
                cline(x-3*DX, Last, x+DX, t, CYAN);
                Last = t;
            }
        }
        }
    }

    if (((_Control.iGmode & 0x40) == 0) && (pDb->sCasIdx == 0) && (_Gen.sMode==3) )
	{
        int clr;
#define plt_s(n)\
        cline(x-3*DX,YS0+(n)*4,  x+DX,YS0+(n)*4,clr);\
        cline(x-3*DX,YS0+(n)*4+1,x+DX,YS0+(n)*4+1,clr)
#define plt_ss(n)\