URL https://opencores.org/ocsvn/pcie_ds_dma/pcie_ds_dma/trunk

Subversion Repositories pcie_ds_dma

[/] [pcie_ds_dma/] [trunk/] [soft/] [linux/] [application/] [wb_test/] [src/] [work/] [wb_teststrm.cpp] - Blame information for rev 2

Go to most recent revision | Details | Compare with Previous | View Log


 
 
#include <stdio.h>
#include <fcntl.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <pthread.h>
#include "utypes.h"
#include "wb_teststrm.h"
#include "cl_wbpex.h"
//#include "useful.h"
 
#define BUFSIZEPKG 62
 
#define TRDIND_MODE0                                    0x0
#define TRDIND_MODE1                                    0x9
#define TRDIND_MODE2                                    0xA
#define TRDIND_SPD_CTRL                                 0x204
#define TRDIND_SPD_ADDR                                 0x205
#define TRDIND_SPD_DATA                                 0x206
 
#define TRDIND_TESTSEQ                                  0x0C
#define TRDIND_CHAN                                             0x10
#define TRDIND_FSRC                                             0x13
#define TRDIND_GAIN                                             0x15
#define TRDIND_CONTROL1                                 0x17
#define TRDIND_DELAY_CTRL                               0x1F
 
 
WB_TestStrm::WB_TestStrm( char* fname,  CL_WBPEX *pex )
{
    lc_status=0;
 
    Terminate=0;
    BlockRd=0;
    BlockOk=0;
    BlockError=0;
    TotalError=0;
 
    pBrd=pex;
    bufIsvi=NULL;
 
    SetDefault();
    GetParamFromFile( fname );
    CalculateParams();
 
   // if(5==isTest) {
   //     rd0.testBuf.buf_check_sine_init( SizeBlockOfWords, fftSize, lowRange, topRange, 3 );
   // }
   // cpuFreq = tk_freq();
    isFirstCallStep=true;
}
 
WB_TestStrm::~WB_TestStrm()
{
    pBrd->StreamDestroy( rd0.Strm );
    //delete bufIsvi; bufIsvi=NULL;
 
}
 
void WB_TestStrm::Prepare( void )
{
 
 
    PrepareAdm();
 
    rd0.trd=trdNo;
    rd0.Strm=strmNo;
    pBrd->StreamInit( rd0.Strm, CntBuffer, SizeBuferOfBytes, rd0.trd, 1, isCycle, isSystem, isAgreeMode );
 
    bufIsvi = new U32[SizeBlockOfWords*2];
    //pBrd->StreamInit( strm, CntBuffer, SizeBuferOfBytes, rd0.trd, 1, 0, 0 );
}
 
void WB_TestStrm::Start( void )
{
    int res = pthread_attr_init(&attrThread_);
    if(res != 0) {
        fprintf(stderr, "%s\n", "Stream not started");
        return;
    }
 
    res = pthread_attr_setdetachstate(&attrThread_, PTHREAD_CREATE_JOINABLE);
    if(res != 0) {
        fprintf(stderr, "%s\n", "Stream not started");
        return;
    }
 
    res = pthread_create(&hThread, &attrThread_, ThreadFunc, this);
    if(res != 0) {
        fprintf(stderr, "%s\n", "Stream not started");
        return;
    }
 
    res = pthread_attr_init(&attrThreadIsvi_);
    if(res != 0) {
        fprintf(stderr, "%s\n", "Stream not started");
        return;
    }
 
    res = pthread_attr_setdetachstate(&attrThreadIsvi_, PTHREAD_CREATE_JOINABLE);
    if(res != 0) {
        fprintf(stderr, "%s\n", "Stream not started");
        return;
    }
 
    res = pthread_create(&hThreadIsvi, &attrThreadIsvi_, ThreadFuncIsvi, this);
    if(res != 0) {
        fprintf(stderr, "%s\n", "Stream not started");
        return;
    }
}
 
void WB_TestStrm::Stop( void )
{
    Terminate=1;
    lc_status=3;
}
 
void WB_TestStrm::Step( void )
{
 
    /*
        pkg_in.testBuf.check_result( &pkg_in.BlockOk , &pkg_in.BlockError, NULL, NULL, NULL );
        rd0.testBuf.check_result( &rd0.BlockOk , &rd0.BlockError, NULL, NULL, NULL );
        rd1.testBuf.check_result( &rd1.BlockOk , &rd1.BlockError, NULL, NULL, NULL );
        */
 
    rd0.testBuf.check_result( &rd0.BlockOk , &rd0.BlockError, NULL, NULL, NULL );
 
    //BRDC_fprintf( stderr, "%10s %10d %10d %10d %10d\n", "PACKAGE :", pkg_out.BlockWr, pkg_in.BlockRd, pkg_in.BlockOk, pkg_in.BlockError );
    //BRDC_fprintf( stderr, "%10s %10d %10d %10d %10d\n", "FIFO_0 :", tr0.BlockWr, rd0.BlockRd, rd0.BlockOk, rd0.BlockError );
    //BRDC_fprintf( stderr, "%10s %10d %10d %10d %10d\n", "FIFO_1 :", tr1.BlockWr, rd1.BlockRd, rd1.BlockOk, rd1.BlockError );
 
    U32 status = 0; //pBrd->RegPeekDir( rd0.trd, 0 ) & 0xFFFF;
    BRDC_fprintf( stderr, "%6s %3d %10d %10d %10d %10d  %9.1f %10.1f     0x%.4X  %d %4d %4f\r", "TRD :", rd0.trd, rd0.BlockWr, rd0.BlockRd, rd0.BlockOk, rd0.BlockError, rd0.VelocityCurrent, rd0.VelocityAvarage, status, IsviStatus, IsviCnt, rd0.fftTime_us );
 
 
 
 
}
 
int WB_TestStrm::isComplete( void )
{
    if( (lc_status==4) && (IsviStatus==100) )
        return 1;
    return 0;
}
 
void WB_TestStrm::GetResult( void )
{
    //if(pkg_in.BlockRd!=0 && pkg_in.BlockError!=0)
    //  printf("%s\n", pkg_in.testBuf.report_word_error());
 
    BRDC_fprintf( stderr, "\n\nРезультат приёма данных через тетраду %d \n", trdNo );
    if(rd0.BlockRd!=0 && rd0.BlockError!=0)
        printf("%s\n", rd0.testBuf.report_word_error());
 
    BRDC_fprintf( stderr, "\n\n" );
}
 
void* WB_TestStrm::ThreadFunc( void* lpvThreadParm )
{
    WB_TestStrm *test=(WB_TestStrm*)lpvThreadParm;
    UINT ret;
    if( !test )
        return 0;
    ret=test->Execute();
    return (void*)ret;
}
 
void* WB_TestStrm::ThreadFuncIsvi( void* lpvThreadParm )
{
    WB_TestStrm *test=(WB_TestStrm*)lpvThreadParm;
    UINT ret;
    if( !test )
        return 0;
 
    Sleep( 200 );
    ret=test->ExecuteIsvi();
    return (void*)ret;
}
 
//! Установка параметров по умолчанию
void WB_TestStrm::SetDefault( void )
{
    int ii=0;
 
    array_cfg[ii++]=STR_CFG(  0, "CntBuffer",                    "16", (U32*)&CntBuffer, "число буферов стрима" );
    array_cfg[ii++]=STR_CFG(  0, "CntBlockInBuffer",     "512",  (U32*)&CntBlockInBuffer, "Число блоков в буфере" );
    array_cfg[ii++]=STR_CFG(  0, "SizeBlockOfWords",     "2048",  (U32*)&SizeBlockOfWords, "Размер блока в словах" );
    array_cfg[ii++]=STR_CFG(  0, "isCycle",                              "1",  (U32*)&isCycle, "1 - Циклический режим работы стрима" );
    array_cfg[ii++]=STR_CFG(  0, "isSystem",                     "1",  (U32*)&isSystem, "1 - выделение системной памяти" );
    array_cfg[ii++]=STR_CFG(  0, "isAgreeMode",                  "0",  (U32*)&isAgreeMode, "1 - согласованный режим" );
 
    array_cfg[ii++]=STR_CFG(  0, "trdNo",        "4",  (U32*)&trdNo, "Номер тетрады" );
    array_cfg[ii++]=STR_CFG(  0, "strmNo",       "0",  (U32*)&strmNo, "Номер стрма" );
    array_cfg[ii++]=STR_CFG(  0, "isTest",       "0",  (U32*)&isTest, "0 - нет, 1 - проверка псевдослучайной последовательности, 2 - проверка тестовой последовательности" );
    array_cfg[ii++]=STR_CFG(  0, "isMainTest",   "0",  (U32*)&isMainTest, "1 - включение режима тестирования в тетраде MAIN" );
 
    array_cfg[ii++]=STR_CFG(  0, "lowRange",     "0",  (U32*)&lowRange, "нижний уровень спектра" );
    array_cfg[ii++]=STR_CFG(  0, "topRange",     "0",  (U32*)&topRange, "верхний уровень спектра" );
    array_cfg[ii++]=STR_CFG(  0, "fftSize",      "2048",  (U32*)&fftSize, "размер БПФ" );
 
 
    fnameAdmReg=NULL;
    array_cfg[ii++]=STR_CFG(  2, "AdmReg",          "adcreg.ini",  (U32*)&fnameAdmReg, "имя файла регистров" );
 
    array_cfg[ii++]=STR_CFG(  0, "isAdmReg",     "0",  (U32*)&isAdmReg, "1 - разрешение записи регистров из файла AdmReg" );
 
    fnameAdmReg2=NULL;
    array_cfg[ii++]=STR_CFG(  2, "AdmReg2",         "adcreg2.ini",  (U32*)&fnameAdmReg2, "имя файла регистров (выполняется после старта стрима)" );
 
    array_cfg[ii++]=STR_CFG(  0, "isAdmReg2",    "0",  (U32*)&isAdmReg2, "1 - разрешение записи регистров из файла AdmReg2" );
 
    fnameIsvi=NULL;
    array_cfg[ii++]=STR_CFG(  2, "ISVI_FILE",   "",  (U32*)&fnameIsvi, "имя файла данных ISVI" );
 
    array_cfg[ii++]=STR_CFG(  0, "ISVI_HEADER",  "0",  (U32*)&IsviHeaderMode, "режим формирования суффикса ISVI, 0 - нет, 1 - DDC, 2 - ADC" );
 
 
    array_cfg[ii++]=STR_CFG(  0, "FifoRdy",              "0",  (U32*)&isFifoRdy, "1 - генератор тестовой последовательности анализирует флаг готовности FIFO" );
 
    array_cfg[ii++]=STR_CFG(  0, "Cnt1", "0",  (U32*)&Cnt1, "Число тактов записи в FIFO, 0 - постоянная запись в FIFO" );
 
    array_cfg[ii++]=STR_CFG(  0, "Cnt2", "0",  (U32*)&Cnt2, "Число тактов паузы при записи в FIFO" );
 
    array_cfg[ii++]=STR_CFG(  0, "DataType",     "0",  (U32*)&DataType, "Тип данных при фиксированном типе блока, 6 - счётчик, 8 - псевдослучайная последовательность" );
 
    array_cfg[ii++]=STR_CFG(  0, "DataFix",      "0",  (U32*)&DataFix, "1 - фиксированный тип блока, 0 - данные в блоке записят от номера блока" );
 
    array_cfg[ii++]=STR_CFG(  0, "isTestCtrl",   "0",  (U32*)&isTestCtrl, "1 - подготовка тетрады TEST_CTRL" );
 
 
    array_cfg[ii++]=STR_CFG(  0, "TestSeq",                      "0",  (U32*)&TestSeq, "Значение регистра TEST_SEQ" );
 
    max_item=ii;
 
    {
        char str[1024];
        for( unsigned ii=0; ii<max_item; ii++ )
        {
            sprintf( str, "%s  %s", array_cfg[ii].name, array_cfg[ii].def );
            GetParamFromStr( str );
        }
 
 
    }
 
}
 
//! Расчёт параметров
void WB_TestStrm::CalculateParams( void )
{
    SizeBlockOfBytes = SizeBlockOfWords * 4;                                            // Размер блока в байтах
    SizeBuferOfBytes    = CntBlockInBuffer * SizeBlockOfBytes  ;        // Размер буфера в байтах
    SizeStreamOfBytes   = CntBuffer * SizeBuferOfBytes;                         // Общий размер буфера стрима
 
    ShowParam();
}
 
//! Отображение параметров
void WB_TestStrm::ShowParam( void )
{
    TF_WorkParam::ShowParam();
 
    BRDC_fprintf( stderr, "Общий размер буфера стрима: %d МБ\n\n", SizeStreamOfBytes/(1024*1024) );
 
}
 
 
U32 WB_TestStrm::Execute( void )
{
    rd0.testBuf.buf_check_start( 32, 64 );
 
/*
    pBrd->RegPokeInd( rd0.trd, 0, 0x2010 );
    pBrd->StreamStart( rd0.Strm );
    pBrd->RegPokeInd( rd0.trd, 0, 0x2038 );
    if( isTestCtrl )
    {
        StartTestCtrl();
    }
 
    if( isAdmReg2 )
        PrepareAdmReg( fnameAdmReg2 );
 
    pBrd->RegPokeInd( 4, 0, 0x2038 );
*/
    rd0.time_last=rd0.time_start=0 ;//GetTickCount();
 
 
    for( ; ; )
    {
        if( Terminate )
        {
            break;
        }
 
        ReceiveData( &rd0 );
        //Sleep( 100 );
    }
/*
    pBrd->RegPokeInd( rd0.trd, 0, 2 );
    Sleep( 200 );
*/
    pBrd->StreamStop( rd0.Strm );
    Sleep( 10 );
 
    lc_status=4;
    return 1;
}
 
 
 
 
void WB_TestStrm::ReceiveData(  ParamExchange *pr )
{
    U32 *ptr;
    U32 *ptrBlock;
    U32 mode=0;
    mode |= pr->DataType<<8;
    mode |= pr->DataFix<<7;
 
    int ret;
    int kk;
 
    //pr->BlockRd++;
    //Sleep( 10 );
    //return;
 
    for( kk=0; kk<16; kk++ )
    {
        ret=pBrd->StreamGetBuf( pr->Strm, &ptr );
        if( ret )
        { // Проверка буфера стрима
 
                for( unsigned ii=0; ii<CntBlockInBuffer; ii++ )
                {
                    ptrBlock=ptr+ii*SizeBlockOfWords;
                    if( isIsvi )
                        IsviStep( ptrBlock );
 
                    if( 1==isTest )
                        pr->testBuf.buf_check_psd( ptrBlock, SizeBlockOfWords );
                    //int a=0;
                    else if( 2==isTest )
                        pr->testBuf.buf_check( ptrBlock, pr->BlockRd, SizeBlockOfWords, BlockMode );
                    else if( 4==isTest )
                        pr->testBuf.buf_check_inv( ptrBlock, SizeBlockOfWords );
 
                    pr->BlockRd++;
                }
                if( isAgreeMode )
                {
                    pBrd->StreamGetBufDone( pr->Strm );
                }
 
        } else
        {
            //Sleep( 0 );
            pr->freeCycle++;
            break;
        }
    }
    //Sleep( 0 );
 
/*
    U32 currentTime = GetTickCount();
    if( (currentTime - pr->time_last)>4000 )
    {
        float t1 = currentTime - pr->time_last;
        float t2 = currentTime - pr->time_start;
        float v = 1000.0*(pr->BlockRd-pr->BlockLast)*SizeBlockOfBytes/t1;
        v/=1024*1024;
        pr->VelocityCurrent=v;
 
        v = 1000.0*(pr->BlockRd)*SizeBlockOfBytes/t2;
        v/=1024*1024;
        pr->VelocityAvarage=v;
        pr->time_last = currentTime;
        pr->BlockLast = pr->BlockRd;
        pr->freeCycleZ=pr->freeCycle;
        pr->freeCycle=0;
 
        if(lowRange == 0)
            pr->testBuf.buf_check_sine_show();
        //pr->testBuf.buf_check_sine_calc_delta();
    }
    //Sleep(1);
*/
 
}
 
 
void WB_TestStrm::PrepareAdm( void )
{
/*
    U32 trd=trdNo;
    U32 id, id_mod, ver;
    BRDC_fprintf( stderr, "\nПодготовка тетрады\n" );
 
 
    id = pBrd->RegPeekInd( trd, 0x100 );
    id_mod = pBrd->RegPeekInd( trd, 0x101 );
    ver = pBrd->RegPeekInd( trd, 0x102 );
 
    //pBrd->RegPokeInd( trd, 0, 0x2038 );
 
    BRDC_fprintf( stderr, "\nТетрада %d  ID: 0x%.2X MOD: %d  VER: %d.%d \n\n",
            trd, id, id_mod, (ver>>8) & 0xFF, ver&0xFF );
 
 
    //if( fnameDDS )
    //  PrepareDDS();
 
 
    if( isMainTest )
        PrepareMain();
 
 
    BlockMode = DataType <<8;
    BlockMode |= DataFix <<7;
 
    if( isTestCtrl )
        PrepareTestCtrl();
 
    if( isAdmReg )
        PrepareAdmReg( fnameAdmReg );
 
 
    IsviStatus=0;
    IsviCnt=0;
    isIsvi=0;
    if( fnameIsvi )
    {
        IsviStatus=1;
        isIsvi=1;
    }
 
*/
}
 
 
 
 
//! Подготовка MAIN
void WB_TestStrm::PrepareMain( void )
{
/*
    if( 4==isTest )
    {
        BRDC_fprintf( stderr, "В тетраде MAIN установлен режим формирования двоично-инверсной последовательности\n" );
    } else
    {
        BRDC_fprintf( stderr, "В тетраде MAIN установлен режим формирования псевдослучайной последовательности\n" );
        pBrd->RegPokeInd( 0, 12, 1 );  // Регистр TEST_MODE[0]=1 - режим формирования псевдослучайной последовательности
    }
    pBrd->RegPokeInd( 0, 0, 2 );   // Сброс FIFO - перевод в начальное состояние
    Sleep( 1 );
    pBrd->RegPokeInd( 0, 0, 0 );
    Sleep( 1 );
*/
}
 
void WB_TestStrm::IsviStep( U32* ptr )
{
    unsigned ii;
    if( (1==IsviStatus) || (4==IsviStatus ) )
    {
        for( ii=0; ii<SizeBlockOfWords; ii++ ) bufIsvi[ii]=ptr[ii];
        IsviStatus++;
    }
}
 
void WB_TestStrm::WriteFlagSinc(int flg, int isNewParam)
{
    int fs = -1;
    int val[2];
 
    char fname[256];
    sprintf( fname, "%s.flg", fnameIsvi );
 
    while( fs==-1 )
    {
        fs = open( fname, O_RDWR|O_CREAT, 0666 );
        Sleep( 10 );
    }
    val[0] = flg;
    val[1] = isNewParam;
    write( fs, val, 8 );
    close( fs );
}
 
int  WB_TestStrm::ReadFlagSinc(void)
{
    int fs = -1;
    int flg;
 
    char fname[256];
    sprintf( fname, "%s.flg", fnameIsvi );
 
    while( fs==-1 )
    {
        fs = open( fname, O_RDWR|O_CREAT, 0666 );
        Sleep( 10 );
    }
    read( fs, &flg, 4 );
    close( fs );
 
    return flg;
}
 
void WB_TestStrm::WriteDataFile( U32 *pBuf, U32 sizew )
{
    char fname[256];
    sprintf( fname, "%s.bin", fnameIsvi );
    int     fl = open(fname, O_WRONLY|O_CREAT|O_TRUNC, 0666);
 
    if( fl==-1 )
    {
        return;
    }
 
 
    write( fl, pBuf, sizew*4 );
 
    write( fl, IsviHeaderStr, IsviHeaderLen );
 
    close( fl );
}
 
 
U32 WB_TestStrm::ExecuteIsvi( void )
{
    for( ; ; )
    {
        if( Terminate )
        {
            break;
        }
 
        int rr;
        switch( IsviStatus )
        {
        case 2: // Подготовка суффикса
            {
                IsviHeaderStr[0]=0;
                /*
                                        switch( IsviHeaderMode )
                                        {
                                                case 1:  SetFileHeaderDdc( SizeBlockOfWords, IsviHeaderStr ); break;
                                                case 2:  SetFileHeaderAdc( SizeBlockOfWords, IsviHeaderStr ); break;
                                        }
                                        */
                IsviHeaderLen = 0; //strlen( IsviHeaderStr );
                WriteFlagSinc(0,0);
                WriteDataFile( bufIsvi, SizeBlockOfWords );
                WriteFlagSinc(0xffffffff,0xffffffff);
 
                IsviCnt++;
                IsviStatus=3;
            }
            break;
 
        case 3:
            {
                rr=ReadFlagSinc();
                if( 0==rr )
                    IsviStatus=4;
 
            }
            break;
 
        case 4:
            // Ожидание получения данных
            Sleep( 100 );
            break;
 
        case 5:
            {
                WriteDataFile( bufIsvi, SizeBlockOfWords );
                WriteFlagSinc(0xffffffff,0 );
                IsviStatus=3;
                IsviCnt++;
            }
            break;
 
        }
 
        Sleep( 100 );
    }
    IsviStatus=100;
    return 0;
}
 
 
#define TRD_CTRL 1
 
#define REG_MUX_CTRL  0x0F
#define REG_GEN_CNT1  0x1A
#define REG_GEN_CNT2  0x1B
#define REG_GEN_CTRL  0x1E
#define REG_GEN_SIZE  0x1F
#define TRD_DIO_IN    6
#define TRD_CTRL      1
//#define TRD_DIO_IN
//! Подготовка TEST_CTRL
 
void WB_TestStrm::PrepareTestCtrl( void )
{
    BRDC_fprintf( stderr, "\nПодготовка тетрады TEST_CTRL\n" );
/*
    BlockMode = DataType <<8;
    BlockMode |= DataFix <<7;
 
    if( !isFifoRdy )
        BlockMode |=0x1000;
 
    U32 block_mode=BlockMode;
 
    pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CTRL, 1 );
 
    //U32 mode0=pBrd->RegPeekInd( TRD_DIO_IN, 0 );
    // pBrd->RegPokeInd( TRD_DIO_IN, 0, 2 );
 
    Sleep( 1 );
 
    //pBrd->RegPokeInd( TRD_DIO_IN, 0, 0 );
 
    pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CTRL, 0 );
 
    pBrd->RegPokeInd( TRD_CTRL, REG_MUX_CTRL, 1 );
 
    U32  val=SizeBlockOfBytes/4096;
 
    pBrd->RegPokeInd( TRD_CTRL, REG_GEN_SIZE, val );
 
    if( block_mode & 0x80 )
    {
        BRDC_fprintf( stderr, "Используется сокращённая тестовая последовательность\r\n" );
    } else
    {
        BRDC_fprintf( stderr, "Используется полная тестовая последовательность\r\n" );
    }
 
 
    if( Cnt1 || Cnt2 )
    {
        pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CNT1, Cnt1 );
        pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CNT2, Cnt2 );
        float sp=1907.348632812 * (Cnt1-1)/(Cnt1+Cnt2-2);
        BRDC_fprintf( stderr, "Установлено ограничение скорости формирования потока:  %6.1f МБайт/с \r\n"
                "REG_CNT1=%d  REGH_CNT2=%d   \r\n", sp, Cnt1, Cnt2 );
        if( block_mode&0x1000 )
        {
            BRDC_fprintf( stderr, "Установлен режим без ожидания готовности FIFO\r\n\r\n" );
        } else
        {
            BRDC_fprintf( stderr, "Установлено ожидание готовности FIFO \r\n\r\n"        );
        }
    }  else
    {
        pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CNT1, 0 );
        pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CNT2, 0 );
        BRDC_fprintf( stderr, "Установлено формирование потока на максимальной скорости: 1907 МБайт/с \r\n"
                "Установлено ожидание готовности FIFO \r\n\r\n"        );
    }
 
*/
}
 
//! Запуск TestCtrl
void WB_TestStrm::StartTestCtrl( void )
{
/*
    U32 ctrl=0x20;
    ctrl|=BlockMode;
    if( Cnt1 || Cnt2 )
        ctrl|=0x40;
 
    if( !isFifoRdy )
        ctrl |=0x1000;
    //  ctrl&= ~0x1000;
    //BRDC_fprintf( stderr, "TEST_CTRL: REG_GEN_CTRL = 0x%.4X \r\n", ctrl );
 
    pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CTRL, ctrl );  // Запуск DIO_IN
 
    //U32 mode0=pBrd->RegPeekInd( 6, 0 );
    //mode0 |=0x30;
    //pBrd->RegPokeInd( 6, 0, mode0 );          // Запуск DIO_IN
*/
 
}
 
 
//! Запись регистров из файла
void WB_TestStrm::PrepareAdmReg( char* fname )
{
    BRDC_fprintf( stderr, "\nУстановка регистров из файла %s\r\n\n", fname );
/*
    FILE *in = fopen( fname, "rt" );
    if( in==NULL )
    {
        throw( "Ошибка доступа к файлу " );
    }
 
    char str[256];
    U32 trd, reg, val;
    int ret;
    for( ; ; )
    {
        if( fgets( str, 200, in )==NULL )
            break;
 
        if( str[0]==';' )
            continue;
 
        ret=sscanf( str, "%i %i %i", &trd, &reg, &val );
        if( 3==ret )
        {
            BRDC_fprintf( stderr, "  TRD: %d  REG[0x%.2X]=0x%.4X \n", trd, reg, val );
            pBrd->RegPokeInd( trd, reg, val );
        }
 
    }
*/
    BRDC_fprintf( stderr, "\n\n" );
}
 

Browse

Tools

Subversion Repositories pcie_ds_dma

[/] [pcie_ds_dma/] [trunk/] [soft/] [linux/] [application/] [wb_test/] [src/] [work/] [wb_teststrm.cpp] - Blame information for rev 2

Line No.	Rev	Author	Line
1	2	dsmv
2
3			`#include <stdio.h>`
4			`#include <fcntl.h>`
5			`#include <pthread.h>`
6			`#include <unistd.h>`
7			`#include <sys/types.h>`
8			`#include <sys/stat.h>`
9			`#include <pthread.h>`
10			`#include "utypes.h"`
11			`#include "wb_teststrm.h"`
12			`#include "cl_wbpex.h"`
13			`//#include "useful.h"`
14
15			`#define BUFSIZEPKG 62`
16
17			`#define TRDIND_MODE0 0x0`
18			`#define TRDIND_MODE1 0x9`
19			`#define TRDIND_MODE2 0xA`
20			`#define TRDIND_SPD_CTRL 0x204`
21			`#define TRDIND_SPD_ADDR 0x205`
22			`#define TRDIND_SPD_DATA 0x206`
23
24			`#define TRDIND_TESTSEQ 0x0C`
25			`#define TRDIND_CHAN 0x10`
26			`#define TRDIND_FSRC 0x13`
27			`#define TRDIND_GAIN 0x15`
28			`#define TRDIND_CONTROL1 0x17`
29			`#define TRDIND_DELAY_CTRL 0x1F`
30
31
32			`WB_TestStrm::WB_TestStrm( char* fname, CL_WBPEX *pex )`
33			`{`
34			`lc_status=0;`
35
36			`Terminate=0;`
37			`BlockRd=0;`
38			`BlockOk=0;`
39			`BlockError=0;`
40			`TotalError=0;`
41
42			`pBrd=pex;`
43			`bufIsvi=NULL;`
44
45			`SetDefault();`
46			`GetParamFromFile( fname );`
47			`CalculateParams();`
48
49			`// if(5==isTest) {`
50			`// rd0.testBuf.buf_check_sine_init( SizeBlockOfWords, fftSize, lowRange, topRange, 3 );`
51			`// }`
52			`// cpuFreq = tk_freq();`
53			`isFirstCallStep=true;`
54			`}`
55
56			`WB_TestStrm::~WB_TestStrm()`
57			`{`
58			`pBrd->StreamDestroy( rd0.Strm );`
59			`//delete bufIsvi; bufIsvi=NULL;`
60
61			`}`
62
63			`void WB_TestStrm::Prepare( void )`
64			`{`
65
66
67			`PrepareAdm();`
68
69			`rd0.trd=trdNo;`
70			`rd0.Strm=strmNo;`
71			`pBrd->StreamInit( rd0.Strm, CntBuffer, SizeBuferOfBytes, rd0.trd, 1, isCycle, isSystem, isAgreeMode );`
72
73			`bufIsvi = new U32[SizeBlockOfWords*2];`
74			`//pBrd->StreamInit( strm, CntBuffer, SizeBuferOfBytes, rd0.trd, 1, 0, 0 );`
75			`}`
76
77			`void WB_TestStrm::Start( void )`
78			`{`
79			`int res = pthread_attr_init(&attrThread_);`
80			`if(res != 0) {`
81			`fprintf(stderr, "%s\n", "Stream not started");`
82			`return;`
83			`}`
84
85			`res = pthread_attr_setdetachstate(&attrThread_, PTHREAD_CREATE_JOINABLE);`
86			`if(res != 0) {`
87			`fprintf(stderr, "%s\n", "Stream not started");`
88			`return;`
89			`}`
90
91			`res = pthread_create(&hThread, &attrThread_, ThreadFunc, this);`
92			`if(res != 0) {`
93			`fprintf(stderr, "%s\n", "Stream not started");`
94			`return;`
95			`}`
96
97			`res = pthread_attr_init(&attrThreadIsvi_);`
98			`if(res != 0) {`
99			`fprintf(stderr, "%s\n", "Stream not started");`
100			`return;`
101			`}`
102
103			`res = pthread_attr_setdetachstate(&attrThreadIsvi_, PTHREAD_CREATE_JOINABLE);`
104			`if(res != 0) {`
105			`fprintf(stderr, "%s\n", "Stream not started");`
106			`return;`
107			`}`
108
109			`res = pthread_create(&hThreadIsvi, &attrThreadIsvi_, ThreadFuncIsvi, this);`
110			`if(res != 0) {`
111			`fprintf(stderr, "%s\n", "Stream not started");`
112			`return;`
113			`}`
114			`}`
115
116			`void WB_TestStrm::Stop( void )`
117			`{`
118			`Terminate=1;`
119			`lc_status=3;`
120			`}`
121
122			`void WB_TestStrm::Step( void )`
123			`{`
124
125			`/*`
126			`pkg_in.testBuf.check_result( &pkg_in.BlockOk , &pkg_in.BlockError, NULL, NULL, NULL );`
127			`rd0.testBuf.check_result( &rd0.BlockOk , &rd0.BlockError, NULL, NULL, NULL );`
128			`rd1.testBuf.check_result( &rd1.BlockOk , &rd1.BlockError, NULL, NULL, NULL );`
129			`*/`
130
131			`rd0.testBuf.check_result( &rd0.BlockOk , &rd0.BlockError, NULL, NULL, NULL );`
132
133			`//BRDC_fprintf( stderr, "%10s %10d %10d %10d %10d\n", "PACKAGE :", pkg_out.BlockWr, pkg_in.BlockRd, pkg_in.BlockOk, pkg_in.BlockError );`
134			`//BRDC_fprintf( stderr, "%10s %10d %10d %10d %10d\n", "FIFO_0 :", tr0.BlockWr, rd0.BlockRd, rd0.BlockOk, rd0.BlockError );`
135			`//BRDC_fprintf( stderr, "%10s %10d %10d %10d %10d\n", "FIFO_1 :", tr1.BlockWr, rd1.BlockRd, rd1.BlockOk, rd1.BlockError );`
136
137			`U32 status = 0; //pBrd->RegPeekDir( rd0.trd, 0 ) & 0xFFFF;`
138			`BRDC_fprintf( stderr, "%6s %3d %10d %10d %10d %10d %9.1f %10.1f 0x%.4X %d %4d %4f\r", "TRD :", rd0.trd, rd0.BlockWr, rd0.BlockRd, rd0.BlockOk, rd0.BlockError, rd0.VelocityCurrent, rd0.VelocityAvarage, status, IsviStatus, IsviCnt, rd0.fftTime_us );`
139
140
141
142
143			`}`
144
145			`int WB_TestStrm::isComplete( void )`
146			`{`
147			`if( (lc_status==4) && (IsviStatus==100) )`
148			`return 1;`
149			`return 0;`
150			`}`
151
152			`void WB_TestStrm::GetResult( void )`
153			`{`
154			`//if(pkg_in.BlockRd!=0 && pkg_in.BlockError!=0)`
155			`// printf("%s\n", pkg_in.testBuf.report_word_error());`
156
157			`BRDC_fprintf( stderr, "\n\nРезультат приёма данных через тетраду %d \n", trdNo );`
158			`if(rd0.BlockRd!=0 && rd0.BlockError!=0)`
159			`printf("%s\n", rd0.testBuf.report_word_error());`
160
161			`BRDC_fprintf( stderr, "\n\n" );`
162			`}`
163
164			`void* WB_TestStrm::ThreadFunc( void* lpvThreadParm )`
165			`{`
166			`WB_TestStrm test=(WB_TestStrm)lpvThreadParm;`
167			`UINT ret;`
168			`if( !test )`
169			`return 0;`
170			`ret=test->Execute();`
171			`return (void*)ret;`
172			`}`
173
174			`void* WB_TestStrm::ThreadFuncIsvi( void* lpvThreadParm )`
175			`{`
176			`WB_TestStrm test=(WB_TestStrm)lpvThreadParm;`
177			`UINT ret;`
178			`if( !test )`
179			`return 0;`
180
181			`Sleep( 200 );`
182			`ret=test->ExecuteIsvi();`
183			`return (void*)ret;`
184			`}`
185
186			`//! Установка параметров по умолчанию`
187			`void WB_TestStrm::SetDefault( void )`
188			`{`
189			`int ii=0;`
190
191			`array_cfg[ii++]=STR_CFG( 0, "CntBuffer", "16", (U32*)&CntBuffer, "число буферов стрима" );`
192			`array_cfg[ii++]=STR_CFG( 0, "CntBlockInBuffer", "512", (U32*)&CntBlockInBuffer, "Число блоков в буфере" );`
193			`array_cfg[ii++]=STR_CFG( 0, "SizeBlockOfWords", "2048", (U32*)&SizeBlockOfWords, "Размер блока в словах" );`
194			`array_cfg[ii++]=STR_CFG( 0, "isCycle", "1", (U32*)&isCycle, "1 - Циклический режим работы стрима" );`
195			`array_cfg[ii++]=STR_CFG( 0, "isSystem", "1", (U32*)&isSystem, "1 - выделение системной памяти" );`
196			`array_cfg[ii++]=STR_CFG( 0, "isAgreeMode", "0", (U32*)&isAgreeMode, "1 - согласованный режим" );`
197
198			`array_cfg[ii++]=STR_CFG( 0, "trdNo", "4", (U32*)&trdNo, "Номер тетрады" );`
199			`array_cfg[ii++]=STR_CFG( 0, "strmNo", "0", (U32*)&strmNo, "Номер стрма" );`
200			`array_cfg[ii++]=STR_CFG( 0, "isTest", "0", (U32*)&isTest, "0 - нет, 1 - проверка псевдослучайной последовательности, 2 - проверка тестовой последовательности" );`
201			`array_cfg[ii++]=STR_CFG( 0, "isMainTest", "0", (U32*)&isMainTest, "1 - включение режима тестирования в тетраде MAIN" );`
202
203			`array_cfg[ii++]=STR_CFG( 0, "lowRange", "0", (U32*)&lowRange, "нижний уровень спектра" );`
204			`array_cfg[ii++]=STR_CFG( 0, "topRange", "0", (U32*)&topRange, "верхний уровень спектра" );`
205			`array_cfg[ii++]=STR_CFG( 0, "fftSize", "2048", (U32*)&fftSize, "размер БПФ" );`
206
207
208			`fnameAdmReg=NULL;`
209			`array_cfg[ii++]=STR_CFG( 2, "AdmReg", "adcreg.ini", (U32*)&fnameAdmReg, "имя файла регистров" );`
210
211			`array_cfg[ii++]=STR_CFG( 0, "isAdmReg", "0", (U32*)&isAdmReg, "1 - разрешение записи регистров из файла AdmReg" );`
212
213			`fnameAdmReg2=NULL;`
214			`array_cfg[ii++]=STR_CFG( 2, "AdmReg2", "adcreg2.ini", (U32*)&fnameAdmReg2, "имя файла регистров (выполняется после старта стрима)" );`
215
216			`array_cfg[ii++]=STR_CFG( 0, "isAdmReg2", "0", (U32*)&isAdmReg2, "1 - разрешение записи регистров из файла AdmReg2" );`
217
218			`fnameIsvi=NULL;`
219			`array_cfg[ii++]=STR_CFG( 2, "ISVI_FILE", "", (U32*)&fnameIsvi, "имя файла данных ISVI" );`
220
221			`array_cfg[ii++]=STR_CFG( 0, "ISVI_HEADER", "0", (U32*)&IsviHeaderMode, "режим формирования суффикса ISVI, 0 - нет, 1 - DDC, 2 - ADC" );`
222
223
224			`array_cfg[ii++]=STR_CFG( 0, "FifoRdy", "0", (U32*)&isFifoRdy, "1 - генератор тестовой последовательности анализирует флаг готовности FIFO" );`
225
226			`array_cfg[ii++]=STR_CFG( 0, "Cnt1", "0", (U32*)&Cnt1, "Число тактов записи в FIFO, 0 - постоянная запись в FIFO" );`
227
228			`array_cfg[ii++]=STR_CFG( 0, "Cnt2", "0", (U32*)&Cnt2, "Число тактов паузы при записи в FIFO" );`
229
230			`array_cfg[ii++]=STR_CFG( 0, "DataType", "0", (U32*)&DataType, "Тип данных при фиксированном типе блока, 6 - счётчик, 8 - псевдослучайная последовательность" );`
231
232			`array_cfg[ii++]=STR_CFG( 0, "DataFix", "0", (U32*)&DataFix, "1 - фиксированный тип блока, 0 - данные в блоке записят от номера блока" );`
233
234			`array_cfg[ii++]=STR_CFG( 0, "isTestCtrl", "0", (U32*)&isTestCtrl, "1 - подготовка тетрады TEST_CTRL" );`
235
236
237			`array_cfg[ii++]=STR_CFG( 0, "TestSeq", "0", (U32*)&TestSeq, "Значение регистра TEST_SEQ" );`
238
239			`max_item=ii;`
240
241			`{`
242			`char str[1024];`
243			`for( unsigned ii=0; ii<max_item; ii++ )`
244			`{`
245			`sprintf( str, "%s %s", array_cfg[ii].name, array_cfg[ii].def );`
246			`GetParamFromStr( str );`
247			`}`
248
249
250			`}`
251
252			`}`
253
254			`//! Расчёт параметров`
255			`void WB_TestStrm::CalculateParams( void )`
256			`{`
257			`SizeBlockOfBytes = SizeBlockOfWords * 4; // Размер блока в байтах`
258			`SizeBuferOfBytes = CntBlockInBuffer * SizeBlockOfBytes ; // Размер буфера в байтах`
259			`SizeStreamOfBytes = CntBuffer * SizeBuferOfBytes; // Общий размер буфера стрима`
260
261			`ShowParam();`
262			`}`
263
264			`//! Отображение параметров`
265			`void WB_TestStrm::ShowParam( void )`
266			`{`
267			`TF_WorkParam::ShowParam();`
268
269			`BRDC_fprintf( stderr, "Общий размер буфера стрима: %d МБ\n\n", SizeStreamOfBytes/(1024*1024) );`
270
271			`}`
272
273
274			`U32 WB_TestStrm::Execute( void )`
275			`{`
276			`rd0.testBuf.buf_check_start( 32, 64 );`
277
278			`/*`
279			`pBrd->RegPokeInd( rd0.trd, 0, 0x2010 );`
280			`pBrd->StreamStart( rd0.Strm );`
281			`pBrd->RegPokeInd( rd0.trd, 0, 0x2038 );`
282			`if( isTestCtrl )`
283			`{`
284			`StartTestCtrl();`
285			`}`
286
287			`if( isAdmReg2 )`
288			`PrepareAdmReg( fnameAdmReg2 );`
289
290			`pBrd->RegPokeInd( 4, 0, 0x2038 );`
291			`*/`
292			`rd0.time_last=rd0.time_start=0 ;//GetTickCount();`
293
294
295			`for( ; ; )`
296			`{`
297			`if( Terminate )`
298			`{`
299			`break;`
300			`}`
301
302			`ReceiveData( &rd0 );`
303			`//Sleep( 100 );`
304			`}`
305			`/*`
306			`pBrd->RegPokeInd( rd0.trd, 0, 2 );`
307			`Sleep( 200 );`
308			`*/`
309			`pBrd->StreamStop( rd0.Strm );`
310			`Sleep( 10 );`
311
312			`lc_status=4;`
313			`return 1;`
314			`}`
315
316
317
318
319			`void WB_TestStrm::ReceiveData( ParamExchange *pr )`
320			`{`
321			`U32 *ptr;`
322			`U32 *ptrBlock;`
323			`U32 mode=0;`
324			`mode \|= pr->DataType<<8;`
325			`mode \|= pr->DataFix<<7;`
326
327			`int ret;`
328			`int kk;`
329
330			`//pr->BlockRd++;`
331			`//Sleep( 10 );`
332			`//return;`
333
334			`for( kk=0; kk<16; kk++ )`
335			`{`
336			`ret=pBrd->StreamGetBuf( pr->Strm, &ptr );`
337			`if( ret )`
338			`{ // Проверка буфера стрима`
339
340			`for( unsigned ii=0; ii<CntBlockInBuffer; ii++ )`
341			`{`
342			`ptrBlock=ptr+ii*SizeBlockOfWords;`
343			`if( isIsvi )`
344			`IsviStep( ptrBlock );`
345
346			`if( 1==isTest )`
347			`pr->testBuf.buf_check_psd( ptrBlock, SizeBlockOfWords );`
348			`//int a=0;`
349			`else if( 2==isTest )`
350			`pr->testBuf.buf_check( ptrBlock, pr->BlockRd, SizeBlockOfWords, BlockMode );`
351			`else if( 4==isTest )`
352			`pr->testBuf.buf_check_inv( ptrBlock, SizeBlockOfWords );`
353
354			`pr->BlockRd++;`
355			`}`
356			`if( isAgreeMode )`
357			`{`
358			`pBrd->StreamGetBufDone( pr->Strm );`
359			`}`
360
361			`} else`
362			`{`
363			`//Sleep( 0 );`
364			`pr->freeCycle++;`
365			`break;`
366			`}`
367			`}`
368			`//Sleep( 0 );`
369
370			`/*`
371			`U32 currentTime = GetTickCount();`
372			`if( (currentTime - pr->time_last)>4000 )`
373			`{`
374			`float t1 = currentTime - pr->time_last;`
375			`float t2 = currentTime - pr->time_start;`
376			`float v = 1000.0(pr->BlockRd-pr->BlockLast)SizeBlockOfBytes/t1;`
377			`v/=1024*1024;`
378			`pr->VelocityCurrent=v;`
379
380			`v = 1000.0(pr->BlockRd)SizeBlockOfBytes/t2;`
381			`v/=1024*1024;`
382			`pr->VelocityAvarage=v;`
383			`pr->time_last = currentTime;`
384			`pr->BlockLast = pr->BlockRd;`
385			`pr->freeCycleZ=pr->freeCycle;`
386			`pr->freeCycle=0;`
387
388			`if(lowRange == 0)`
389			`pr->testBuf.buf_check_sine_show();`
390			`//pr->testBuf.buf_check_sine_calc_delta();`
391			`}`
392			`//Sleep(1);`
393			`*/`
394
395			`}`
396
397
398			`void WB_TestStrm::PrepareAdm( void )`
399			`{`
400			`/*`
401			`U32 trd=trdNo;`
402			`U32 id, id_mod, ver;`
403			`BRDC_fprintf( stderr, "\nПодготовка тетрады\n" );`
404
405
406			`id = pBrd->RegPeekInd( trd, 0x100 );`
407			`id_mod = pBrd->RegPeekInd( trd, 0x101 );`
408			`ver = pBrd->RegPeekInd( trd, 0x102 );`
409
410			`//pBrd->RegPokeInd( trd, 0, 0x2038 );`
411
412			`BRDC_fprintf( stderr, "\nТетрада %d ID: 0x%.2X MOD: %d VER: %d.%d \n\n",`
413			`trd, id, id_mod, (ver>>8) & 0xFF, ver&0xFF );`
414
415
416			`//if( fnameDDS )`
417			`// PrepareDDS();`
418
419
420			`if( isMainTest )`
421			`PrepareMain();`
422
423
424			`BlockMode = DataType <<8;`
425			`BlockMode \|= DataFix <<7;`
426
427			`if( isTestCtrl )`
428			`PrepareTestCtrl();`
429
430			`if( isAdmReg )`
431			`PrepareAdmReg( fnameAdmReg );`
432
433
434			`IsviStatus=0;`
435			`IsviCnt=0;`
436			`isIsvi=0;`
437			`if( fnameIsvi )`
438			`{`
439			`IsviStatus=1;`
440			`isIsvi=1;`
441			`}`
442
443			`*/`
444			`}`
445
446
447
448
449			`//! Подготовка MAIN`
450			`void WB_TestStrm::PrepareMain( void )`
451			`{`
452			`/*`
453			`if( 4==isTest )`
454			`{`
455			`BRDC_fprintf( stderr, "В тетраде MAIN установлен режим формирования двоично-инверсной последовательности\n" );`
456			`} else`
457			`{`
458			`BRDC_fprintf( stderr, "В тетраде MAIN установлен режим формирования псевдослучайной последовательности\n" );`
459			`pBrd->RegPokeInd( 0, 12, 1 ); // Регистр TEST_MODE[0]=1 - режим формирования псевдослучайной последовательности`
460			`}`
461			`pBrd->RegPokeInd( 0, 0, 2 ); // Сброс FIFO - перевод в начальное состояние`
462			`Sleep( 1 );`
463			`pBrd->RegPokeInd( 0, 0, 0 );`
464			`Sleep( 1 );`
465			`*/`
466			`}`
467
468			`void WB_TestStrm::IsviStep( U32* ptr )`
469			`{`
470			`unsigned ii;`
471			`if( (1==IsviStatus) \|\| (4==IsviStatus ) )`
472			`{`
473			`for( ii=0; ii<SizeBlockOfWords; ii++ ) bufIsvi[ii]=ptr[ii];`
474			`IsviStatus++;`
475			`}`
476			`}`
477
478			`void WB_TestStrm::WriteFlagSinc(int flg, int isNewParam)`
479			`{`
480			`int fs = -1;`
481			`int val[2];`
482
483			`char fname[256];`
484			`sprintf( fname, "%s.flg", fnameIsvi );`
485
486			`while( fs==-1 )`
487			`{`
488			`fs = open( fname, O_RDWR\|O_CREAT, 0666 );`
489			`Sleep( 10 );`
490			`}`
491			`val[0] = flg;`
492			`val[1] = isNewParam;`
493			`write( fs, val, 8 );`
494			`close( fs );`
495			`}`
496
497			`int WB_TestStrm::ReadFlagSinc(void)`
498			`{`
499			`int fs = -1;`
500			`int flg;`
501
502			`char fname[256];`
503			`sprintf( fname, "%s.flg", fnameIsvi );`
504
505			`while( fs==-1 )`
506			`{`
507			`fs = open( fname, O_RDWR\|O_CREAT, 0666 );`
508			`Sleep( 10 );`
509			`}`
510			`read( fs, &flg, 4 );`
511			`close( fs );`
512
513			`return flg;`
514			`}`
515
516			`void WB_TestStrm::WriteDataFile( U32 *pBuf, U32 sizew )`
517			`{`
518			`char fname[256];`
519			`sprintf( fname, "%s.bin", fnameIsvi );`
520			`int fl = open(fname, O_WRONLY\|O_CREAT\|O_TRUNC, 0666);`
521
522			`if( fl==-1 )`
523			`{`
524			`return;`
525			`}`
526
527
528			`write( fl, pBuf, sizew*4 );`
529
530			`write( fl, IsviHeaderStr, IsviHeaderLen );`
531
532			`close( fl );`
533			`}`
534
535
536			`U32 WB_TestStrm::ExecuteIsvi( void )`
537			`{`
538			`for( ; ; )`
539			`{`
540			`if( Terminate )`
541			`{`
542			`break;`
543			`}`
544
545			`int rr;`
546			`switch( IsviStatus )`
547			`{`
548			`case 2: // Подготовка суффикса`
549			`{`
550			`IsviHeaderStr[0]=0;`
551			`/*`
552			`switch( IsviHeaderMode )`
553			`{`
554			`case 1: SetFileHeaderDdc( SizeBlockOfWords, IsviHeaderStr ); break;`
555			`case 2: SetFileHeaderAdc( SizeBlockOfWords, IsviHeaderStr ); break;`
556			`}`
557			`*/`
558			`IsviHeaderLen = 0; //strlen( IsviHeaderStr );`
559			`WriteFlagSinc(0,0);`
560			`WriteDataFile( bufIsvi, SizeBlockOfWords );`
561			`WriteFlagSinc(0xffffffff,0xffffffff);`
562
563			`IsviCnt++;`
564			`IsviStatus=3;`
565			`}`
566			`break;`
567
568			`case 3:`
569			`{`
570			`rr=ReadFlagSinc();`
571			`if( 0==rr )`
572			`IsviStatus=4;`
573
574			`}`
575			`break;`
576
577			`case 4:`
578			`// Ожидание получения данных`
579			`Sleep( 100 );`
580			`break;`
581
582			`case 5:`
583			`{`
584			`WriteDataFile( bufIsvi, SizeBlockOfWords );`
585			`WriteFlagSinc(0xffffffff,0 );`
586			`IsviStatus=3;`
587			`IsviCnt++;`
588			`}`
589			`break;`
590
591			`}`
592
593			`Sleep( 100 );`
594			`}`
595			`IsviStatus=100;`
596			`return 0;`
597			`}`
598
599
600			`#define TRD_CTRL 1`
601
602			`#define REG_MUX_CTRL 0x0F`
603			`#define REG_GEN_CNT1 0x1A`
604			`#define REG_GEN_CNT2 0x1B`
605			`#define REG_GEN_CTRL 0x1E`
606			`#define REG_GEN_SIZE 0x1F`
607			`#define TRD_DIO_IN 6`
608			`#define TRD_CTRL 1`
609			`//#define TRD_DIO_IN`
610			`//! Подготовка TEST_CTRL`
611
612			`void WB_TestStrm::PrepareTestCtrl( void )`
613			`{`
614			`BRDC_fprintf( stderr, "\nПодготовка тетрады TEST_CTRL\n" );`
615			`/*`
616			`BlockMode = DataType <<8;`
617			`BlockMode \|= DataFix <<7;`
618
619			`if( !isFifoRdy )`
620			`BlockMode \|=0x1000;`
621
622			`U32 block_mode=BlockMode;`
623
624			`pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CTRL, 1 );`
625
626			`//U32 mode0=pBrd->RegPeekInd( TRD_DIO_IN, 0 );`
627			`// pBrd->RegPokeInd( TRD_DIO_IN, 0, 2 );`
628
629			`Sleep( 1 );`
630
631			`//pBrd->RegPokeInd( TRD_DIO_IN, 0, 0 );`
632
633			`pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CTRL, 0 );`
634
635			`pBrd->RegPokeInd( TRD_CTRL, REG_MUX_CTRL, 1 );`
636
637			`U32 val=SizeBlockOfBytes/4096;`
638
639			`pBrd->RegPokeInd( TRD_CTRL, REG_GEN_SIZE, val );`
640
641			`if( block_mode & 0x80 )`
642			`{`
643			`BRDC_fprintf( stderr, "Используется сокращённая тестовая последовательность\r\n" );`
644			`} else`
645			`{`
646			`BRDC_fprintf( stderr, "Используется полная тестовая последовательность\r\n" );`
647			`}`
648
649
650			`if( Cnt1 \|\| Cnt2 )`
651			`{`
652			`pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CNT1, Cnt1 );`
653			`pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CNT2, Cnt2 );`
654			`float sp=1907.348632812 * (Cnt1-1)/(Cnt1+Cnt2-2);`
655			`BRDC_fprintf( stderr, "Установлено ограничение скорости формирования потока: %6.1f МБайт/с \r\n"`
656			`"REG_CNT1=%d REGH_CNT2=%d \r\n", sp, Cnt1, Cnt2 );`
657			`if( block_mode&0x1000 )`
658			`{`
659			`BRDC_fprintf( stderr, "Установлен режим без ожидания готовности FIFO\r\n\r\n" );`
660			`} else`
661			`{`
662			`BRDC_fprintf( stderr, "Установлено ожидание готовности FIFO \r\n\r\n" );`
663			`}`
664			`} else`
665			`{`
666			`pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CNT1, 0 );`
667			`pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CNT2, 0 );`
668			`BRDC_fprintf( stderr, "Установлено формирование потока на максимальной скорости: 1907 МБайт/с \r\n"`
669			`"Установлено ожидание готовности FIFO \r\n\r\n" );`
670			`}`
671
672			`*/`
673			`}`
674
675			`//! Запуск TestCtrl`
676			`void WB_TestStrm::StartTestCtrl( void )`
677			`{`
678			`/*`
679			`U32 ctrl=0x20;`
680			`ctrl\|=BlockMode;`
681			`if( Cnt1 \|\| Cnt2 )`
682			`ctrl\|=0x40;`
683
684			`if( !isFifoRdy )`
685			`ctrl \|=0x1000;`
686			`// ctrl&= ~0x1000;`
687			`//BRDC_fprintf( stderr, "TEST_CTRL: REG_GEN_CTRL = 0x%.4X \r\n", ctrl );`
688
689			`pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CTRL, ctrl ); // Запуск DIO_IN`
690
691			`//U32 mode0=pBrd->RegPeekInd( 6, 0 );`
692			`//mode0 \|=0x30;`
693			`//pBrd->RegPokeInd( 6, 0, mode0 ); // Запуск DIO_IN`
694			`*/`
695
696			`}`
697
698
699			`//! Запись регистров из файла`
700			`void WB_TestStrm::PrepareAdmReg( char* fname )`
701			`{`
702			`BRDC_fprintf( stderr, "\nУстановка регистров из файла %s\r\n\n", fname );`
703			`/*`
704			`FILE *in = fopen( fname, "rt" );`
705			`if( in==NULL )`
706			`{`
707			`throw( "Ошибка доступа к файлу " );`
708			`}`
709
710			`char str[256];`
711			`U32 trd, reg, val;`
712			`int ret;`
713			`for( ; ; )`
714			`{`
715			`if( fgets( str, 200, in )==NULL )`
716			`break;`
717
718			`if( str[0]==';' )`
719			`continue;`
720
721			`ret=sscanf( str, "%i %i %i", &trd, &reg, &val );`
722			`if( 3==ret )`
723			`{`
724			`BRDC_fprintf( stderr, " TRD: %d REG[0x%.2X]=0x%.4X \n", trd, reg, val );`
725			`pBrd->RegPokeInd( trd, reg, val );`
726			`}`
727
728			`}`
729			`*/`
730			`BRDC_fprintf( stderr, "\n\n" );`
731			`}`
732