예제 #1
0
파일: SI_test.cpp 프로젝트: ITeast/ECE0206
///////////////////////////////////////////////////////////////////////
//
//  “≈—“  входных каналов
//
//////////////////////////////////////////////////////////////////////
BOOL inputChannelTest()
{
	
	ULONG	param[256];
	DWORD tick1;

	unsigned int	ii;
  	for( ii = 0; ii<256; ii++)
	{
		param[ii] = 0x70000000 + (ii<<16) + (((~ii)<<8)&0xff00) + ii;
	}

	BUF256x32_write( param);

	// параметры выходного канала
	UCHAR  soErr_en = 0;	// = 0  - выдача 32-битных слов; =1 выдача 33-битных слов;  = 255 - выдача 31-битных слов
	UCHAR  soParity = 1;	//= 0  - без формировани¤ нечетности; = 1 - формирование бита нечетности
	UCHAR  soFreq;	//выдача на частотах 
						//	= 0    12,5 √ц;
						//	 = 1    50 √ц;
						//	 = 2    100  √ц;
	UCHAR  soArrayDim = 0;	//размер массива (1..255слов или 0 дл¤ массива размером 256 слов);
	UCHAR  soDelay = 0;	//дл¤ многократной и циклической выдачи: интервал между массивами = 0, 1, 2, .., 255 (что соответствует  0  10,24  20,48  ..  2611,2мс);  дл¤ однократной выдачи = 0
	UCHAR  soArrayNumber = 0;	// дл¤ однократной выдачи = 1;                          дл¤ многократной выдачи - количество                                    выдаваемых массивов (2..255);                          дл¤ циклической выдачи = 0. 


	// параметры входных каналов
	UCHAR  siChanNumber;	//номер канала (1..4) 
	UCHAR  siMode;	// = 0  - рабочий режим; = 1 - режим самоконтрол¤
	UCHAR  siParity = 1;	//= 0  - без контрол¤ нечетности; = 1 - контроль нечетности
	UCHAR  siFreq;	//=0 - прием на частотах 36-100 √ц; = 1 - прием на частотах 11-14,5  √ц

	
	DeviceIoControl (
		hECE0206
		,ECE02061_XP_SET_SHORT_MODE
		,NULL
		,0
		,NULL
		,0
		,&nOutput 
		,NULL  );

	for( siChanNumber =1; siChanNumber<=4; siChanNumber++)
	{
		printf("Channel # %d\n",siChanNumber);

		//	режим самоконтроль/с заглушкой 

		for( siMode = 1; siMode <=1; siMode--)
		{
			printf("   %s\n",siMode ? "Self-checking mode" : "Operating mode (with stub)");

			// проверка на всех диапазонах

			for( soFreq = 0; soFreq <=2; soFreq++)
			{
				siFreq = soFreq ? 0 : 1;

				frequency_printf(siFreq, soFreq);

				// пуск входных каналов
				for(UCHAR siChanNumber1 =1; siChanNumber1<=4; siChanNumber1++)
				{


					SI_pusk( siChanNumber1, siMode, siParity, siFreq);
					tick = GetTickCount();
					while (( GetTickCount()- tick)<100) {};
					SI_clear_array(siChanNumber1);
				}

				// пуск выходного канала

				SO_pusk(soErr_en, soParity, soFreq, soArrayDim, soDelay, soArrayNumber);

				tick = GetTickCount();
				do
				{
					tick1 = GetTickCount();
					printf("%d \r",(tick1 - tick));
				}while ((tick1 - tick)<5000) ;


				if(inputParamCodeCheck( siChanNumber
						,256
						,param))
				{

					SO_stop();
					SI_stop(1);
					SI_stop(2);
					SI_stop(3);
					SI_stop(4);

					return 1;
				}


				SO_stop();
				SI_stop(1);
				SI_stop(2);
				SI_stop(3);
				SI_stop(4);

			}//soFreq 
		}// siMode = 1/0
	}//for( siChanNumber =1; siChanNumber<=4; siChanNumber++)

	return 0;
}
예제 #2
0
파일: SO_test.c 프로젝트: ellysh/ece-0206
static int  outputChannelTest()
{
    DWORD    minPeriodTemplate;
    DWORD    maxPeriodTemplate;

    DWORD tick1;
    int array_number;

    unsigned int    ii;
    int f;

    UCHAR  siChanNumber = INPUTCHANNELNUMBER;
    UCHAR  siMode;
    UCHAR  siParity;
    UCHAR  siFreq;

    UCHAR  soErr_en;
    UCHAR  soParity;
    UCHAR  soFreq;
    UCHAR  soArrayDim;
    UCHAR  soDelay;
    UCHAR  soArrayNumber;

    UCHAR ArrayDimVariantsInd;
    UCHAR ArrayNumberVariantsInd;

    ULONG   param [256];

    ioctl ( hECE0206, ECE02061_SET_LONG_MODE);



    //
    for( ii = 0; ii<256; ii++)
    {
        param[ii] = 0x70000000 + (ii<<16) + (((~ii)<<8)&0xff00) + ii;
    }

    BUF256x32_write( param);

    siParity = 1;
    soParity = 1;
    soErr_en = 0;


    printf(" SINGLE OUTPUT:\n");
    soArrayNumber = 1;
    soDelay = 0;

    for( siMode = 1; siMode <=1; siMode--)
    {
        printf("   %s\n",siMode ? "Self-checking mode" : "Operating mode (with stub)");

        for( soFreq = 0; soFreq <=2; soFreq++)
        {
            siFreq = soFreq ? 0 : 1;

            frequency_printf(siFreq, soFreq);

            if (soFreq)
            {
                minPeriodTemplate = (720/soFreq)-10;
                maxPeriodTemplate = (720/soFreq)+10;
            }
            else
            {
                minPeriodTemplate = 2800;
                maxPeriodTemplate = 2960;
            }

            //

            UCHAR    ArrayDimVariants[4] = {1,128,255,0};

            for( ArrayDimVariantsInd = 0; ArrayDimVariantsInd <4; ArrayDimVariantsInd++)
            {
                soArrayDim = ArrayDimVariants[ArrayDimVariantsInd];

                unsigned int soArrayDim_int = soArrayDim ? soArrayDim : 256;

                printf("          SO Array Dimension = %3d\n",soArrayDim_int);

                CHANNEL_PUSK;

                intervalMs(1500);

                if(inputParamCodeCheck( siChanNumber
                            , soArrayDim_int
                            , param))
                {
                    SI_stop(siChanNumber);
                    return 1;
                }

                if(test_period( siChanNumber
                            ,soArrayDim_int
                            ,minPeriodTemplate
                            ,maxPeriodTemplate))
                {
                    SI_stop(siChanNumber);
                    return 1;
                }

                SI_stop(siChanNumber);

            }//soArrayDim
        }//soFreq
    }// siMode = 1/0


    UCHAR    ArrayNumberVariants[2] = {2,5};

    for( ArrayNumberVariantsInd = 0; ArrayNumberVariantsInd <2; ArrayNumberVariantsInd++)
    {
        soArrayNumber = ArrayNumberVariants[ArrayNumberVariantsInd];
        printf(" MULTIPLE OUTPUT:  SO Array Number = %3d\n",soArrayNumber);

        for( siMode = 1; siMode <=1; siMode--)
        {
            printf("   %s\n",siMode ? "Self-checking mode" : "Operating mode (with stub)");

            for( soFreq = 0; soFreq <=2; soFreq++)
            {
                siFreq = soFreq ? 0 : 1;

                frequency_printf(siFreq, soFreq);

                soArrayDim = 1;
                soDelay = 0;
                printf("          SO Array Dimension = 1\n");

                CHANNEL_PUSK;

                startTime = clock();
                startTime1 = startTime;
                while (((startTime1 - startTime)*1000/CLOCKS_PER_SEC)<1000)
                {
                    startTime1 = clock();
                    printf("%d \r",(startTime1 - startTime)*1000/CLOCKS_PER_SEC);
                };

                INPUTPARAM inputParam[256];
                read_array_CC(siChanNumber, inputParam );

                array_number = 0;

                for( ii = 0; ii<256; ii++)
                    if(param[0] == (inputParam[ii].param&0x7fffffff)) array_number++;

                if(array_number != soArrayNumber)
                {
                    printf("          ERROR: input array number = %d\n",array_number);
                    #ifdef myDEBUG
                    for( f=0;f<256;f++)
                    {
                        printf("paramN:%3d  inputParam: %08x timer:%08x error:%02x\n"
                            ,f
                            ,inputParam[f].param
                            ,inputParam[f].timer
                            ,inputParam[f].error);
                    }
                    #endif
                    SI_stop(siChanNumber);
                    return 1;
                }

                SI_stop(siChanNumber);

                soArrayDim = 0;
                printf("          SO Array Dimension = 256\n");
                soDelay = 0;
                array_number = 0;
                INPUTPARAM  bufOutput57;

                CHANNEL_PUSK;

                startTime = clock();
                do                            //
                {
                    read_parameter_CC(siChanNumber
                        ,255
                        ,&bufOutput57);
                    startTime1 = clock();
                    printf("%d \r",(startTime1 - startTime)*1000/CLOCKS_PER_SEC);
                }while((bufOutput57.param==0)&&(((startTime1 - startTime)*1000/CLOCKS_PER_SEC)<1000));

                if(bufOutput57.param==0)
                {
                    printf("          ERROR: first input array timeout \n");
                    SI_stop(siChanNumber);
                    return 1;
                }
                DWORD  timerTemp0 = bufOutput57.timer;
                array_number++;

                startTime = clock();
                do
                {
                    read_parameter_CC(siChanNumber
                        ,255
                        ,&bufOutput57);
                    if(bufOutput57.timer !=timerTemp0)
                    {
                        array_number++;
                        timerTemp0 = bufOutput57.timer;
                    }

                    startTime1 = clock();
                    printf("%d \r",(startTime1 - startTime)*1000/CLOCKS_PER_SEC);
                }while (((startTime1 - startTime)*1000/CLOCKS_PER_SEC)<1000*(unsigned long int)soArrayNumber);//

/*            printf("\n2. param: %08x  timer: %08x  error: %02x\n"
                ,bufOutput57.param
                ,bufOutput57.timer
                ,bufOutput57.error);
*/
                    if(array_number!=soArrayNumber)
                    {
                        printf("          ERROR: array_number = %d \n",array_number);
                        SI_stop(siChanNumber);
                        return 1;
                    }

                    SI_stop(siChanNumber);

            }//soFreq
        }// siMode = 1/0
    }


    return 0;
}