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

Subversion Repositories pcie_ds_dma

[/] [pcie_ds_dma/] [trunk/] [soft/] [linux/] [application/] [adm_test/] [src/] [work/] [tf_teststrm.cpp] - Blame information for rev 8

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


 
 
#include <stdio.h>
#include <fcntl.h>
#include <pthread.h>
#include <unistd.h>
#include <math.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <pthread.h>
#include "utypes.h"
#include "tf_teststrm.h"
#include "cl_ambpex.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
 
//-----------------------------------------------------------------------------
 
int GetTickCount(void)
{
    return time( NULL);
}
 
//-----------------------------------------------------------------------------
 
TF_TestStrm::TF_TestStrm( char* fname,  CL_AMBPEX *pex )
{
    lc_status=0;
 
    Terminate=0;
    BlockRd=0;
    BlockOk=0;
    BlockError=0;
    TotalError=0;
 
    pBrd=pex;
    bufIsvi=NULL;
 
    SetDefault();
    GetParamFromFile( fname );
    CalculateParams();
 
    isFirstCallStep=true;
}
 
//-----------------------------------------------------------------------------
 
TF_TestStrm::~TF_TestStrm()
{
    pBrd->StreamDestroy( rd0.Strm );
    delete bufIsvi;
    bufIsvi=NULL;
}
 
//-----------------------------------------------------------------------------
 
void TF_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];
}
 
//-----------------------------------------------------------------------------
 
void TF_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 TF_TestStrm::Stop( void )
{
    Terminate=1;
    lc_status=3;
    //BRDC_fprintf( stderr, "TF_TestStrm::Stop(): lc_status = %d\n", lc_status );
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::Step( void )
{
    rd0.testBuf.check_result( &rd0.BlockOk , &rd0.BlockError, NULL, NULL, NULL );
 
    U32 status = pBrd->RegPeekDir( rd0.trd, 0 ) & 0xFFFF;
 
    U32 cnt_rd=rd0.BlockRd;
    if( isRestart )
        cnt_rd = cntRestart;
 
    BRDC_fprintf( stderr, "%6s %3d %10d %10d %10d %10d  %9.1f %10.1f     0x%.4X  %d %4d\r", "TRD :", rd0.trd, rd0.BlockWr, cnt_rd, rd0.BlockOk, rd0.BlockError, rd0.VelocityCurrent, rd0.VelocityAvarage, status, IsviStatus, IsviCnt );
 
    if( isSystemMonitor )
    {
        unsigned temp;
        float ty;
        pBrd->RegPokeInd( 0, 0x210, 0 );
        temp = pBrd->RegPeekInd( 0, 0x211 );
 
        temp >>=6;
        temp &= 0x3FF;
        ty = (temp*503.975)/1024-273.15;
 
        BRDC_fprintf( stderr, "%6s %3d %10.1f\n", "SYSMON", 0, ty  );
 
    }
}
 
//-----------------------------------------------------------------------------
 
int TF_TestStrm::isComplete( void )
{
    if( (lc_status==4) && (IsviStatus==100) )
        return 1;
    return 0;
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::GetResult( void )
{
    BRDC_fprintf( stderr, "\n\nResult of receiving data from trd %d \n", trdNo );
    if(rd0.BlockRd!=0 && rd0.BlockError!=0)
        printf("%s\n", rd0.testBuf.report_word_error());
 
    BRDC_fprintf( stderr, "\n\n" );
}
 
//-----------------------------------------------------------------------------
 
void* TF_TestStrm::ThreadFunc( void* lpvThreadParm )
{
    TF_TestStrm *test=(TF_TestStrm*)lpvThreadParm;
    UINT ret;
    if( !test )
        return 0;
    ret=test->Execute();
    return (void*)ret;
}
 
//-----------------------------------------------------------------------------
 
void* TF_TestStrm::ThreadFuncIsvi( void* lpvThreadParm )
{
    TF_TestStrm *test=(TF_TestStrm*)lpvThreadParm;
    UINT ret;
    if( !test )
        return 0;
 
    Sleep( 200 );
    ret=test->ExecuteIsvi();
    return (void*)ret;
}
 
//-----------------------------------------------------------------------------
 
//! Установка параметров по умолчанию
void TF_TestStrm::SetDefault( void )
{
    int ii=0;
 
    array_cfg[ii++]=STR_CFG(  0, "CntBuffer",            "16", (U32*)&CntBuffer, "Stream buffers number" );
    array_cfg[ii++]=STR_CFG(  0, "CntBlockInBuffer",     "512",  (U32*)&CntBlockInBuffer, "Blocks in buffer" );
    array_cfg[ii++]=STR_CFG(  0, "SizeBlockOfWords",     "2048",  (U32*)&SizeBlockOfWords, "Block size (in words)" );
    array_cfg[ii++]=STR_CFG(  0, "isCycle",              "1",  (U32*)&isCycle, "1 - Stream working in cycle mode" );
    array_cfg[ii++]=STR_CFG(  0, "isSystem",             "1",  (U32*)&isSystem, "1 - system memory allocation" );
    array_cfg[ii++]=STR_CFG(  0, "isAgreeMode",          "0",  (U32*)&isAgreeMode, "1 - adjust mode" );
    array_cfg[ii++]=STR_CFG(  0, "isRestart",            "0",  (U32*)&isRestart, "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" );
 
    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 TF_TestStrm::CalculateParams( void )
{
    SizeBlockOfBytes = SizeBlockOfWords * 4;                                            // Размер блока в байтах
    SizeBuferOfBytes    = CntBlockInBuffer * SizeBlockOfBytes  ;        // Размер буфера в байтах
    SizeStreamOfBytes   = CntBuffer * SizeBuferOfBytes;                         // Общий размер буфера стрима
 
    ShowParam();
}
 
//-----------------------------------------------------------------------------
 
//! Отображение параметров
void TF_TestStrm::ShowParam( void )
{
    TF_WorkParam::ShowParam();
 
    BRDC_fprintf( stderr, "Total stream buffer size: %d MB\n\n", SizeStreamOfBytes/(1024*1024) );
}
 
//-----------------------------------------------------------------------------
 
U32 TF_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=GetTickCount();
 
 
    for( ; ; )
    {
        if( Terminate )
        {
            break;
        }
 
        ReceiveData( &rd0 );
    }
 
    pBrd->RegPokeInd( rd0.trd, 0, 2 );
    Sleep( 200 );
 
    pBrd->StreamStop( rd0.Strm );
    Sleep( 10 );
 
    lc_status=4;
 
    //BRDC_fprintf( stderr, "TF_TestStrm::Execute(): lc_status = %d\n", lc_status );
 
    return 1;
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::ReceiveData(  ParamExchange *pr )
{
    U32 *ptr;
    U32 *ptrBlock;
    U32 mode=0;
    mode |= pr->DataType<<8;
    mode |= pr->DataFix<<7;
 
    int ret;
    int kk;
 
    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 );
            }
            if( (1==isRestart) && (pr->BlockRd==(CntBuffer*CntBlockInBuffer) ) )
            {
                RestartAdc();
            }
 
        } else {
 
            pr->freeCycle++;
            break;
        }
    }
 
    U32 currentTime = GetTickCount();
    if( (currentTime - pr->time_last)>10 )
    {
        float t1 = currentTime - pr->time_last;
        float t2 = currentTime - pr->time_start;
        float v = 1.0*(pr->BlockRd-pr->BlockLast)*SizeBlockOfBytes/t1;
        v/=1024*1024;
        pr->VelocityCurrent=v;
 
        v = 1.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;
    }
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::PrepareAdm( void )
{
    U32 trd=trdNo;
    U32 id, id_mod, ver;
    BRDC_fprintf( stderr, "\nPreparing tetrade\n" );
 
 
    id = pBrd->RegPeekInd( trd, 0x100 );
    id_mod = pBrd->RegPeekInd( trd, 0x101 );
    ver = pBrd->RegPeekInd( trd, 0x102 );
 
    BRDC_fprintf( stderr, "\nTetrade %d  ID: 0x%.2X MOD: %d  VER: %d.%d \n\n",
                  trd, id, id_mod, (ver>>8) & 0xFF, ver&0xFF );
 
 
    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 TF_TestStrm::PrepareMain( void )
{
 
    if( 4==isTest )
    {
        BRDC_fprintf( stderr, "In tetrade MAIN set mode of binary-inversion sequence\n" );
    } else
    {
        BRDC_fprintf( stderr, "In tetrade MAIN set of pseudo-random mode sequence\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 TF_TestStrm::IsviStep( U32* ptr )
{
    unsigned ii;
    if( (1==IsviStatus) || (4==IsviStatus ) )
    {
        for( ii=0; ii<SizeBlockOfWords; ii++ ) bufIsvi[ii]=ptr[ii];
        IsviStatus++;
    }
}
 
//-----------------------------------------------------------------------------
 
void TF_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;
    int res = write( fs, val, 8 );
    if(res < 0) {
        BRDC_fprintf( stderr, "Error write flag sync\r\n" );
    }
    close( fs );
}
 
//-----------------------------------------------------------------------------
 
int  TF_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 );
    }
    int res = read( fs, &flg, 4 );
    if(res < 0) {
        BRDC_fprintf( stderr, "Error read flag sync\r\n" );
    }
    close( fs );
 
    return flg;
}
 
//-----------------------------------------------------------------------------
 
void TF_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;
    }
 
 
    int res = write( fl, pBuf, sizew*4 );
    if(res < 0) {
        BRDC_fprintf( stderr, "Error write ISVI data\r\n" );
    }
 
    res = write( fl, IsviHeaderStr, IsviHeaderLen );
    if(res < 0) {
        BRDC_fprintf( stderr, "Error write ISVI header\r\n" );
    }
 
    close( fl );
}
 
//-----------------------------------------------------------------------------
 
U32 TF_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
 
//-----------------------------------------------------------------------------
//! Подготовка TEST_CTRL
void TF_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 TF_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 TF_TestStrm::PrepareAdmReg( char* fname )
{
    BRDC_fprintf( stderr, "\nSetting up ADM registers from file: %s\r\n\n", fname );
 
    FILE *in = fopen( fname, "rt" );
    if( in==NULL )
    {
        throw( "Error file access" );
    }
 
    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" );
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::RestartAdc( void )
{
    pBrd->RegPokeInd( rd0.trd, 0, 2 );
    Sleep( 100 );
 
    pBrd->StreamStop( rd0.Strm );
    Sleep( 100 );
 
    pBrd->RegPokeInd( rd0.trd, 0, 0x2000 );
 
    pBrd->StreamStart( rd0.Strm );
    Sleep( 100 );
 
    rd0.BlockRd=0;
    cntRestart++;
 
    pBrd->RegPokeInd( rd0.trd, 0, 0x2038 );
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::RestartDac( void )
{
    U32 trdDac = 5;
 
    pBrd->RegPokeInd( trdDac, 0, 2 );
    Sleep( 100 );
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::PrepareDac( void )
{
    U32 trdDac = 5;
 
    fprintf(stderr,"%s(): Start DAC\n", __FUNCTION__);
    pBrd->RegPokeInd( trdDac, 0x0, 0x0010 );
    Sleep( 1 );
    pBrd->RegPokeInd( trdDac, 0x0, 0x0030 );
}
 
//-----------------------------------------------------------------------------

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	6	v.karak	`#include <math.h>`
8	2	dsmv	`#include <sys/types.h>`
9			`#include <sys/stat.h>`
10			`#include <pthread.h>`
11			`#include "utypes.h"`
12			`#include "tf_teststrm.h"`
13			`#include "cl_ambpex.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	6	v.karak	`#define TRDIND_CHAN 0x10`
26			`#define TRDIND_FSRC 0x13`
27			`#define TRDIND_GAIN 0x15`
28	2	dsmv	`#define TRDIND_CONTROL1 0x17`
29			`#define TRDIND_DELAY_CTRL 0x1F`
30
31	6	v.karak	`//-----------------------------------------------------------------------------`
32
33	2	dsmv	`int GetTickCount(void)`
34			`{`
35			`return time( NULL);`
36			`}`
37
38	6	v.karak	`//-----------------------------------------------------------------------------`
39
40	2	dsmv	`TF_TestStrm::TF_TestStrm( char* fname, CL_AMBPEX *pex )`
41			`{`
42			`lc_status=0;`
43
44			`Terminate=0;`
45			`BlockRd=0;`
46			`BlockOk=0;`
47			`BlockError=0;`
48			`TotalError=0;`
49
50			`pBrd=pex;`
51			`bufIsvi=NULL;`
52
53			`SetDefault();`
54			`GetParamFromFile( fname );`
55			`CalculateParams();`
56
57			`isFirstCallStep=true;`
58			`}`
59
60	6	v.karak	`//-----------------------------------------------------------------------------`
61
62	2	dsmv	`TF_TestStrm::~TF_TestStrm()`
63			`{`
64			`pBrd->StreamDestroy( rd0.Strm );`
65	6	v.karak	`delete bufIsvi;`
66			`bufIsvi=NULL;`
67	2	dsmv	`}`
68
69	6	v.karak	`//-----------------------------------------------------------------------------`
70
71	2	dsmv	`void TF_TestStrm::Prepare( void )`
72			`{`
73			`PrepareAdm();`
74
75			`rd0.trd=trdNo;`
76			`rd0.Strm=strmNo;`
77			`pBrd->StreamInit( rd0.Strm, CntBuffer, SizeBuferOfBytes, rd0.trd, 1, isCycle, isSystem, isAgreeMode );`
78
79			`bufIsvi = new U32[SizeBlockOfWords*2];`
80			`}`
81
82	6	v.karak	`//-----------------------------------------------------------------------------`
83
84	2	dsmv	`void TF_TestStrm::Start( void )`
85			`{`
86			`int res = pthread_attr_init(&attrThread_);`
87			`if(res != 0) {`
88			`fprintf(stderr, "%s\n", "Stream not started");`
89			`return;`
90			`}`
91
92			`res = pthread_attr_setdetachstate(&attrThread_, PTHREAD_CREATE_JOINABLE);`
93			`if(res != 0) {`
94			`fprintf(stderr, "%s\n", "Stream not started");`
95			`return;`
96			`}`
97
98			`res = pthread_create(&hThread, &attrThread_, ThreadFunc, this);`
99			`if(res != 0) {`
100			`fprintf(stderr, "%s\n", "Stream not started");`
101			`return;`
102			`}`
103
104			`res = pthread_attr_init(&attrThreadIsvi_);`
105			`if(res != 0) {`
106			`fprintf(stderr, "%s\n", "Stream not started");`
107			`return;`
108			`}`
109
110			`res = pthread_attr_setdetachstate(&attrThreadIsvi_, PTHREAD_CREATE_JOINABLE);`
111			`if(res != 0) {`
112			`fprintf(stderr, "%s\n", "Stream not started");`
113			`return;`
114			`}`
115
116			`res = pthread_create(&hThreadIsvi, &attrThreadIsvi_, ThreadFuncIsvi, this);`
117			`if(res != 0) {`
118			`fprintf(stderr, "%s\n", "Stream not started");`
119			`return;`
120			`}`
121			`}`
122
123	6	v.karak	`//-----------------------------------------------------------------------------`
124
125	2	dsmv	`void TF_TestStrm::Stop( void )`
126			`{`
127			`Terminate=1;`
128			`lc_status=3;`
129	6	v.karak	`//BRDC_fprintf( stderr, "TF_TestStrm::Stop(): lc_status = %d\n", lc_status );`
130	2	dsmv	`}`
131
132	6	v.karak	`//-----------------------------------------------------------------------------`
133
134	2	dsmv	`void TF_TestStrm::Step( void )`
135			`{`
136	6	v.karak	`rd0.testBuf.check_result( &rd0.BlockOk , &rd0.BlockError, NULL, NULL, NULL );`
137	2	dsmv
138	6	v.karak	`U32 status = pBrd->RegPeekDir( rd0.trd, 0 ) & 0xFFFF;`
139	2	dsmv
140	6	v.karak	`U32 cnt_rd=rd0.BlockRd;`
141			`if( isRestart )`
142			`cnt_rd = cntRestart;`
143	2	dsmv
144	6	v.karak	`BRDC_fprintf( stderr, "%6s %3d %10d %10d %10d %10d %9.1f %10.1f 0x%.4X %d %4d\r", "TRD :", rd0.trd, rd0.BlockWr, cnt_rd, rd0.BlockOk, rd0.BlockError, rd0.VelocityCurrent, rd0.VelocityAvarage, status, IsviStatus, IsviCnt );`
145	2	dsmv
146	6	v.karak	`if( isSystemMonitor )`
147			`{`
148			`unsigned temp;`
149			`float ty;`
150			`pBrd->RegPokeInd( 0, 0x210, 0 );`
151			`temp = pBrd->RegPeekInd( 0, 0x211 );`
152	2	dsmv
153	6	v.karak	`temp >>=6;`
154			`temp &= 0x3FF;`
155			`ty = (temp*503.975)/1024-273.15;`
156	2	dsmv
157	6	v.karak	`BRDC_fprintf( stderr, "%6s %3d %10.1f\n", "SYSMON", 0, ty );`
158	2	dsmv
159	6	v.karak	`}`
160	2	dsmv	`}`
161
162	6	v.karak	`//-----------------------------------------------------------------------------`
163
164	2	dsmv	`int TF_TestStrm::isComplete( void )`
165			`{`
166			`if( (lc_status==4) && (IsviStatus==100) )`
167			`return 1;`
168			`return 0;`
169			`}`
170
171	6	v.karak	`//-----------------------------------------------------------------------------`
172
173	2	dsmv	`void TF_TestStrm::GetResult( void )`
174			`{`
175	6	v.karak	`BRDC_fprintf( stderr, "\n\nResult of receiving data from trd %d \n", trdNo );`
176	2	dsmv	`if(rd0.BlockRd!=0 && rd0.BlockError!=0)`
177			`printf("%s\n", rd0.testBuf.report_word_error());`
178
179			`BRDC_fprintf( stderr, "\n\n" );`
180			`}`
181
182	6	v.karak	`//-----------------------------------------------------------------------------`
183
184	2	dsmv	`void* TF_TestStrm::ThreadFunc( void* lpvThreadParm )`
185			`{`
186			`TF_TestStrm test=(TF_TestStrm)lpvThreadParm;`
187			`UINT ret;`
188			`if( !test )`
189			`return 0;`
190			`ret=test->Execute();`
191			`return (void*)ret;`
192			`}`
193
194	6	v.karak	`//-----------------------------------------------------------------------------`
195
196	2	dsmv	`void* TF_TestStrm::ThreadFuncIsvi( void* lpvThreadParm )`
197			`{`
198			`TF_TestStrm test=(TF_TestStrm)lpvThreadParm;`
199			`UINT ret;`
200			`if( !test )`
201			`return 0;`
202
203			`Sleep( 200 );`
204			`ret=test->ExecuteIsvi();`
205			`return (void*)ret;`
206			`}`
207
208	6	v.karak	`//-----------------------------------------------------------------------------`
209
210	2	dsmv	`//! Установка параметров по умолчанию`
211			`void TF_TestStrm::SetDefault( void )`
212			`{`
213			`int ii=0;`
214
215	6	v.karak	`array_cfg[ii++]=STR_CFG( 0, "CntBuffer", "16", (U32*)&CntBuffer, "Stream buffers number" );`
216	2	dsmv	`array_cfg[ii++]=STR_CFG( 0, "CntBlockInBuffer", "512", (U32*)&CntBlockInBuffer, "Blocks in buffer" );`
217			`array_cfg[ii++]=STR_CFG( 0, "SizeBlockOfWords", "2048", (U32*)&SizeBlockOfWords, "Block size (in words)" );`
218	6	v.karak	`array_cfg[ii++]=STR_CFG( 0, "isCycle", "1", (U32*)&isCycle, "1 - Stream working in cycle mode" );`
219			`array_cfg[ii++]=STR_CFG( 0, "isSystem", "1", (U32*)&isSystem, "1 - system memory allocation" );`
220			`array_cfg[ii++]=STR_CFG( 0, "isAgreeMode", "0", (U32*)&isAgreeMode, "1 - adjust mode" );`
221			`array_cfg[ii++]=STR_CFG( 0, "isRestart", "0", (U32*)&isRestart, "1 - Перезапуск АЦП" );`
222	2	dsmv
223			`array_cfg[ii++]=STR_CFG( 0, "trdNo", "4", (U32*)&trdNo, "Номер тетрады" );`
224			`array_cfg[ii++]=STR_CFG( 0, "strmNo", "0", (U32*)&strmNo, "Номер стрма" );`
225			`array_cfg[ii++]=STR_CFG( 0, "isTest", "0", (U32*)&isTest, "0 - нет, 1 - проверка псевдослучайной последовательности, 2 - проверка тестовой последовательности" );`
226			`array_cfg[ii++]=STR_CFG( 0, "isMainTest", "0", (U32*)&isMainTest, "1 - включение режима тестирования в тетраде MAIN" );`
227
228			`fnameAdmReg=NULL;`
229	6	v.karak	`array_cfg[ii++]=STR_CFG( 2, "AdmReg", "adcreg.ini", (U32*)&fnameAdmReg, "имя файла регистров" );`
230	2	dsmv
231			`array_cfg[ii++]=STR_CFG( 0, "isAdmReg", "0", (U32*)&isAdmReg, "1 - разрешение записи регистров из файла AdmReg" );`
232
233			`fnameAdmReg2=NULL;`
234	6	v.karak	`array_cfg[ii++]=STR_CFG( 2, "AdmReg2", "adcreg2.ini", (U32*)&fnameAdmReg2, "имя файла регистров (выполняется после старта стрима)" );`
235	2	dsmv
236			`array_cfg[ii++]=STR_CFG( 0, "isAdmReg2", "0", (U32*)&isAdmReg2, "1 - разрешение записи регистров из файла AdmReg2" );`
237
238			`fnameIsvi=NULL;`
239			`array_cfg[ii++]=STR_CFG( 2, "ISVI_FILE", "", (U32*)&fnameIsvi, "имя файла данных ISVI" );`
240
241			`array_cfg[ii++]=STR_CFG( 0, "ISVI_HEADER", "0", (U32*)&IsviHeaderMode, "режим формирования суффикса ISVI, 0 - нет, 1 - DDC, 2 - ADC" );`
242
243	6	v.karak	`array_cfg[ii++]=STR_CFG( 0, "FifoRdy", "0", (U32*)&isFifoRdy, "1 - генератор тестовой последовательности анализирует флаг готовности FIFO" );`
244	2	dsmv
245			`array_cfg[ii++]=STR_CFG( 0, "Cnt1", "0", (U32*)&Cnt1, "Число тактов записи в FIFO, 0 - постоянная запись в FIFO" );`
246
247			`array_cfg[ii++]=STR_CFG( 0, "Cnt2", "0", (U32*)&Cnt2, "Число тактов паузы при записи в FIFO" );`
248
249			`array_cfg[ii++]=STR_CFG( 0, "DataType", "0", (U32*)&DataType, "Тип данных при фиксированном типе блока, 6 - счётчик, 8 - псевдослучайная последовательность" );`
250
251			`array_cfg[ii++]=STR_CFG( 0, "DataFix", "0", (U32*)&DataFix, "1 - фиксированный тип блока, 0 - данные в блоке записят от номера блока" );`
252
253			`array_cfg[ii++]=STR_CFG( 0, "isTestCtrl", "0", (U32*)&isTestCtrl, "1 - подготовка тетрады TEST_CTRL" );`
254
255	6	v.karak	`array_cfg[ii++]=STR_CFG( 0, "TestSeq", "0", (U32*)&TestSeq, "Значение регистра TEST_SEQ" );`
256	2	dsmv
257			`max_item=ii;`
258
259			`{`
260	6	v.karak	`char str[1024];`
261	2	dsmv	`for( unsigned ii=0; ii<max_item; ii++ )`
262	6	v.karak	`{`
263	2	dsmv	`sprintf( str, "%s %s", array_cfg[ii].name, array_cfg[ii].def );`
264			`GetParamFromStr( str );`
265	6	v.karak	`}`
266	2	dsmv	`}`
267			`}`
268
269	6	v.karak	`//-----------------------------------------------------------------------------`
270
271	2	dsmv	`//! Расчёт параметров`
272			`void TF_TestStrm::CalculateParams( void )`
273			`{`
274			`SizeBlockOfBytes = SizeBlockOfWords * 4; // Размер блока в байтах`
275			`SizeBuferOfBytes = CntBlockInBuffer * SizeBlockOfBytes ; // Размер буфера в байтах`
276			`SizeStreamOfBytes = CntBuffer * SizeBuferOfBytes; // Общий размер буфера стрима`
277
278			`ShowParam();`
279			`}`
280
281	6	v.karak	`//-----------------------------------------------------------------------------`
282
283	2	dsmv	`//! Отображение параметров`
284			`void TF_TestStrm::ShowParam( void )`
285			`{`
286			`TF_WorkParam::ShowParam();`
287
288			`BRDC_fprintf( stderr, "Total stream buffer size: %d MB\n\n", SizeStreamOfBytes/(1024*1024) );`
289			`}`
290
291	6	v.karak	`//-----------------------------------------------------------------------------`
292	2	dsmv
293			`U32 TF_TestStrm::Execute( void )`
294			`{`
295			`rd0.testBuf.buf_check_start( 32, 64 );`
296
297			`pBrd->RegPokeInd( rd0.trd, 0, 0x2010 );`
298			`pBrd->StreamStart( rd0.Strm );`
299			`pBrd->RegPokeInd( rd0.trd, 0, 0x2038 );`
300			`if( isTestCtrl )`
301			`{`
302			`StartTestCtrl();`
303			`}`
304
305	6	v.karak	`if( isAdmReg2 ) {`
306	2	dsmv	`PrepareAdmReg( fnameAdmReg2 );`
307	6	v.karak	`}`
308	2	dsmv
309			`pBrd->RegPokeInd( 4, 0, 0x2038 );`
310
311			`rd0.time_last=rd0.time_start=GetTickCount();`
312
313
314			`for( ; ; )`
315			`{`
316			`if( Terminate )`
317			`{`
318			`break;`
319			`}`
320
321			`ReceiveData( &rd0 );`
322			`}`
323	6	v.karak
324	2	dsmv	`pBrd->RegPokeInd( rd0.trd, 0, 2 );`
325			`Sleep( 200 );`
326
327			`pBrd->StreamStop( rd0.Strm );`
328			`Sleep( 10 );`
329
330			`lc_status=4;`
331	6	v.karak
332			`//BRDC_fprintf( stderr, "TF_TestStrm::Execute(): lc_status = %d\n", lc_status );`
333
334	2	dsmv	`return 1;`
335			`}`
336
337	6	v.karak	`//-----------------------------------------------------------------------------`
338	2	dsmv
339			`void TF_TestStrm::ReceiveData( ParamExchange *pr )`
340			`{`
341			`U32 *ptr;`
342			`U32 *ptrBlock;`
343			`U32 mode=0;`
344			`mode \|= pr->DataType<<8;`
345			`mode \|= pr->DataFix<<7;`
346
347			`int ret;`
348			`int kk;`
349
350			`for( kk=0; kk<16; kk++ )`
351			`{`
352			`ret=pBrd->StreamGetBuf( pr->Strm, &ptr );`
353			`if( ret )`
354			`{ // Проверка буфера стрима`
355
356	6	v.karak	`for( unsigned ii=0; ii<CntBlockInBuffer; ii++ )`
357			`{`
358			`ptrBlock=ptr+ii*SizeBlockOfWords;`
359			`if( isIsvi )`
360			`IsviStep( ptrBlock );`
361	2	dsmv
362	6	v.karak	`if( 1==isTest )`
363			`pr->testBuf.buf_check_psd( ptrBlock, SizeBlockOfWords );`
364			`//int a=0;`
365			`else if( 2==isTest )`
366			`pr->testBuf.buf_check( ptrBlock, pr->BlockRd, SizeBlockOfWords, BlockMode );`
367			`else if( 4==isTest )`
368			`pr->testBuf.buf_check_inv( ptrBlock, SizeBlockOfWords );`
369	2	dsmv
370	6	v.karak	`pr->BlockRd++;`
371			`}`
372			`if( isAgreeMode )`
373			`{`
374			`pBrd->StreamGetBufDone( pr->Strm );`
375			`}`
376			`if( (1==isRestart) && (pr->BlockRd==(CntBuffer*CntBlockInBuffer) ) )`
377			`{`
378			`RestartAdc();`
379			`}`
380	2	dsmv
381	6	v.karak	`} else {`
382
383	2	dsmv	`pr->freeCycle++;`
384			`break;`
385			`}`
386			`}`
387
388			`U32 currentTime = GetTickCount();`
389			`if( (currentTime - pr->time_last)>10 )`
390			`{`
391			`float t1 = currentTime - pr->time_last;`
392			`float t2 = currentTime - pr->time_start;`
393			`float v = 1.0(pr->BlockRd-pr->BlockLast)SizeBlockOfBytes/t1;`
394			`v/=1024*1024;`
395			`pr->VelocityCurrent=v;`
396
397			`v = 1.0(pr->BlockRd)SizeBlockOfBytes/t2;`
398			`v/=1024*1024;`
399			`pr->VelocityAvarage=v;`
400			`pr->time_last = currentTime;`
401			`pr->BlockLast = pr->BlockRd;`
402			`pr->freeCycleZ=pr->freeCycle;`
403			`pr->freeCycle=0;`
404			`}`
405			`}`
406
407	6	v.karak	`//-----------------------------------------------------------------------------`
408	2	dsmv
409			`void TF_TestStrm::PrepareAdm( void )`
410			`{`
411			`U32 trd=trdNo;`
412			`U32 id, id_mod, ver;`
413			`BRDC_fprintf( stderr, "\nPreparing tetrade\n" );`
414
415
416			`id = pBrd->RegPeekInd( trd, 0x100 );`
417			`id_mod = pBrd->RegPeekInd( trd, 0x101 );`
418			`ver = pBrd->RegPeekInd( trd, 0x102 );`
419
420			`BRDC_fprintf( stderr, "\nTetrade %d ID: 0x%.2X MOD: %d VER: %d.%d \n\n",`
421	6	v.karak	`trd, id, id_mod, (ver>>8) & 0xFF, ver&0xFF );`
422	2	dsmv
423
424			`if( isMainTest )`
425			`PrepareMain();`
426
427			`BlockMode = DataType <<8;`
428			`BlockMode \|= DataFix <<7;`
429
430			`if( isTestCtrl )`
431			`PrepareTestCtrl();`
432
433			`if( isAdmReg )`
434			`PrepareAdmReg( fnameAdmReg );`
435
436			`IsviStatus=0;`
437			`IsviCnt=0;`
438			`isIsvi=0;`
439			`if( fnameIsvi )`
440			`{`
441			`IsviStatus=1;`
442			`isIsvi=1;`
443			`}`
444			`}`
445
446	6	v.karak	`//-----------------------------------------------------------------------------`
447	2	dsmv	`//! Подготовка MAIN`
448			`void TF_TestStrm::PrepareMain( void )`
449			`{`
450
451			`if( 4==isTest )`
452			`{`
453	6	v.karak	`BRDC_fprintf( stderr, "In tetrade MAIN set mode of binary-inversion sequence\n" );`
454	2	dsmv	`} else`
455			`{`
456	6	v.karak	`BRDC_fprintf( stderr, "In tetrade MAIN set of pseudo-random mode sequence\n" );`
457	2	dsmv	`pBrd->RegPokeInd( 0, 12, 1 ); // Регистр TEST_MODE[0]=1 - режим формирования псевдослучайной последовательности`
458			`}`
459			`pBrd->RegPokeInd( 0, 0, 2 ); // Сброс FIFO - перевод в начальное состояние`
460			`Sleep( 1 );`
461			`pBrd->RegPokeInd( 0, 0, 0 );`
462			`Sleep( 1 );`
463			`}`
464
465	6	v.karak	`//-----------------------------------------------------------------------------`
466
467	2	dsmv	`void TF_TestStrm::IsviStep( U32* ptr )`
468			`{`
469			`unsigned ii;`
470			`if( (1==IsviStatus) \|\| (4==IsviStatus ) )`
471			`{`
472			`for( ii=0; ii<SizeBlockOfWords; ii++ ) bufIsvi[ii]=ptr[ii];`
473			`IsviStatus++;`
474			`}`
475			`}`
476
477	6	v.karak	`//-----------------------------------------------------------------------------`
478
479	2	dsmv	`void TF_TestStrm::WriteFlagSinc(int flg, int isNewParam)`
480			`{`
481			`int fs = -1;`
482			`int val[2];`
483
484			`char fname[256];`
485			`sprintf( fname, "%s.flg", fnameIsvi );`
486
487			`while( fs==-1 )`
488			`{`
489			`fs = open( fname, O_RDWR\|O_CREAT, 0666 );`
490			`Sleep( 10 );`
491			`}`
492			`val[0] = flg;`
493			`val[1] = isNewParam;`
494	6	v.karak	`int res = write( fs, val, 8 );`
495			`if(res < 0) {`
496			`BRDC_fprintf( stderr, "Error write flag sync\r\n" );`
497			`}`
498	2	dsmv	`close( fs );`
499			`}`
500

Browse

Tools

Subversion Repositories pcie_ds_dma

[/] [pcie_ds_dma/] [trunk/] [soft/] [linux/] [application/] [adm_test/] [src/] [work/] [tf_teststrm.cpp] - Blame information for rev 8