URL
https://opencores.org/ocsvn/pcie_ds_dma/pcie_ds_dma/trunk
Subversion Repositories pcie_ds_dma
Compare Revisions
- This comparison shows the changes necessary to convert path
/pcie_ds_dma/trunk/soft/linux/application/wb_test/src/work
- from Rev 30 to Rev 31
- ↔ Reverse comparison
Rev 30 → Rev 31
/wb_teststrm.h
27,8 → 27,8
float fftTime_us; |
TF_TestBufM2 testBuf; |
|
U32 time_start; |
U32 time_last; |
long time_start; |
long time_last; |
U32 BlockLast; |
U32 freeCycle; |
U32 freeCycleZ; |
57,13 → 57,10
}; |
|
UINT ThreadId; |
UINT ThreadIdIsvi; |
|
pthread_t hThread; |
pthread_attr_t attrThread_; |
|
pthread_t hThreadIsvi; |
pthread_attr_t attrThreadIsvi_; |
|
CL_WBPEX *pBrd; |
|
83,7 → 80,6
virtual void Step( void ); |
|
U32 Execute( void ); |
U32 ExecuteIsvi( void ); |
|
|
//! Установка параметров по умолчанию |
97,10 → 93,6
|
|
U32 Terminate; |
U32 BlockRd; |
U32 BlockOk; |
U32 BlockError; |
U32 TotalError; |
|
U32 CntBuffer; // Число буферов стрима |
U32 CntBlockInBuffer; // Число блоков в буфере |
112,14 → 104,9
U32 isSystem; // 1 - системная память |
U32 isAgreeMode; // 1 - согласованный режим |
|
U32 trdNo; // номер тетрады |
U32 strmNo; // номер стрима |
U32 isTest; // 1 - проверка псевдослучайной последовательности, 2 - проверка тестовой последовательности |
U32 isMainTest; // 1 - включение режима тестирования в тетараде MAIN |
|
U32 lowRange; |
U32 topRange; |
U32 fftSize; |
|
U32 isFifoRdy; // 1 - генератор тестовой последовательности анализирует флаг готовности FIFO |
U32 Cnt1; // Число тактов записи в FIFO, 0 - постоянная запись в FIFO |
129,44 → 116,15
|
U32 BlockMode; // режим проверки |
|
U32 isTestCtrl; // 1 - подготовка тетрады TEST_CTRL |
|
char* fnameAdcParam; // Имя файла параметров для режима АЦП |
char* fnameDdcParam; // Имя файла параметров для режима DDC |
char* fnameIsvi; // Имя файла данных ISVI |
|
char* fnameAdmReg; // Имя файла регистров |
U32 isAdmReg; // 1 - разрешение записи регистров из файла fnameAdmReg |
|
char* fnameAdmReg2; // Имя файла регистров (выполняется после старта стрима) |
U32 isAdmReg2; // 1 - разрешение записи регистров из файла fnameAdmReg2 |
|
U32 isIsvi; // 1 - вывод в ISVI |
U32* bufIsvi; // Буфер данных ISVI |
char IsviHeaderStr[1024]; // суффикс ISVI |
U32 IsviHeaderLen; |
U32 IsviHeaderMode; // режим формирования суффикса ISVI, 0 - нет, 1 - DDC, 2 - ADC |
U32 IsviStatus; // состояние вывода в ISVI |
U32 IsviCnt; // число выведенных кадров в ISVI |
|
void IsviStep( U32* ptr ); |
void WriteFlagSinc(int flg, int isNewParam); |
int ReadFlagSinc(void); |
void WriteDataFile( U32 *pBuf, U32 sizew ); |
|
U32 lc_status; |
float cpuFreq; |
|
ParamExchange rd0; |
|
|
|
//void SendPkg( ParamExchange *pr ); |
//void ReceivePkg( ParamExchange *pr ); |
//void SendData( ParamExchange *pr ); |
void ReceiveData( ParamExchange *pr ); |
|
U32 TestSeq; // Региср управления режимом формирования тестовой последовательности |
|
|
private : |
175,17 → 133,8
|
void PrepareWb( void ); |
|
void PrepareAdmReg( char* fname ); |
|
|
//! Подготовка MAIN |
void PrepareMain( void ); |
|
//! Подготовка TEST_CTRL |
void PrepareTestCtrl( void ); |
|
//! Запуск TestCtrl |
void StartTestCtrl( void ); |
|
|
}; |
/main.cpp
104,7 → 104,6
} |
|
|
//printf( "Файл инициализации: %s\n", fname ); |
try |
{ |
CL_WBPEX *pBrd = &g_Board; |
116,18 → 115,7
BRDC_fprintf( stderr, _BRDC("Board PEXDRV open succesfully\n") ); |
|
|
/* |
for( trd=0; trd<8; trd++ ) |
pBrd->RegPokeInd( trd, 0, 1 ); |
|
for( trd=0; trd<8; trd++ ) |
for( int ii=1; ii<32; ii++ ) |
pBrd->RegPokeInd( trd, ii, 0 ); |
|
for( trd=0; trd<8; trd++ ) |
pBrd->RegPokeInd( trd, 0, 0 ); |
*/ |
|
} else |
{ |
BRDC_fprintf( stderr, _BRDC("Error during open PEXDRV: ret=0x%.8X\n"), ret ); |
135,12 → 123,9
exit(-1); |
} |
|
//printf( "\nShowPldInfo\n" ); |
ShowWishboneInfo( pBrd ); |
//} |
|
|
//#if 0 |
if( fname[0]=='o' ) |
pTest = new WB_TestStrmOut( fname, pBrd ); |
else |
207,7 → 192,7
if( isFirstCallStep || isTwoTest ) |
{ |
|
BRDC_fprintf( stdout, _BRDC("%10s %10s %10s %10s %10s %10s %10s %10s\n"), _BRDC(""), _BRDC("BLOCK_WR"), _BRDC("BLOCK_RD"), _BRDC("BLOCK_OK"), _BRDC("BLOCK_ERR"), _BRDC("SPD_CURR"), _BRDC("SPD_AVR"), _BRDC("STATUS")); |
BRDC_fprintf( stdout, _BRDC("%10s %10s %10s %10s %10s %10s %10s %10s %-10s %-6s\n"), _BRDC(""), _BRDC("BLOCK_WR"), _BRDC("BLOCK_RD"), _BRDC("BLOCK_OK"), _BRDC("BLOCK_ERR"), _BRDC("SPD_CURR"), _BRDC("SPD_AVR"), _BRDC("STATUS"), _BRDC("SIG"), _BRDC("TIME")); |
BRDC_fprintf( stdout, _BRDC("\n")); |
} |
|
/wb_teststrm.cpp
11,6 → 11,7
#include "utypes.h" |
#include "wb_teststrm.h" |
#include "cl_wbpex.h" |
#include "sys/time.h" |
//#include "useful.h" |
|
#define BUFSIZEPKG 62 |
30,27 → 31,27
#define TRDIND_DELAY_CTRL 0x1F |
|
|
long GetTickCount(void) |
{ |
struct timeval tv; |
struct timezone tz; |
gettimeofday(&tv, &tz); |
long ret=tv.tv_sec*1000 + tv.tv_usec/1000; |
return ret; |
} |
|
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; |
} |
|
57,7 → 58,6
WB_TestStrm::~WB_TestStrm() |
{ |
pBrd->StreamDestroy( rd0.Strm ); |
//delete bufIsvi; bufIsvi=NULL; |
|
} |
|
67,12 → 67,10
|
PrepareWb(); |
|
rd0.trd=trdNo; |
rd0.trd=0; |
rd0.Strm=strmNo; |
pBrd->StreamInit( rd0.Strm, CntBuffer, SizeBuferOfBytes, rd0.trd, 1, isCycle, isSystem, isAgreeMode ); |
pBrd->StreamInit( rd0.Strm, CntBuffer, SizeBuferOfBytes, 0, 1, isCycle, isSystem, isAgreeMode ); |
|
bufIsvi = new U32[SizeBlockOfWords*2]; |
// pBrd->StreamInit( rd0.Strm, CntBuffer, SizeBuferOfBytes, U32(0x3000),U32(1), 0, 1, U32(0) ); |
} |
|
void WB_TestStrm::Start( void ) |
95,23 → 93,6
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 ) |
123,25 → 104,22
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 ); |
long currentTime = GetTickCount(); |
int min, sec_all, sec; |
sec_all= currentTime-rd0.time_start; |
sec_all/=1000; |
sec=sec_all%60; |
min=sec_all/60; |
|
|
U32 status = pBrd->wb_block_read( 1, 0x10 ); |
rd0.BlockWr = pBrd->wb_block_read( 1, 0x11 ); |
U32 sig = pBrd->wb_block_read( 1, 0x12 ); |
//pBrd->RegPeekDir( rd0.trd, 0 ) & 0xFFFF; |
//rd0.BlockWr=pBrd->wb_block_read( 1, 0x11 ); |
|
BRDC_fprintf( stdout, "%6s %3d %10d %10d %10d %10d %9.1f %10.1f 0x%.4X 0x%.8X %4d %4f\r", "TRD :", rd0.trd, rd0.BlockWr, rd0.BlockRd, rd0.BlockOk, rd0.BlockError, rd0.VelocityCurrent, rd0.VelocityAvarage, status, sig, IsviCnt, rd0.fftTime_us ); |
BRDC_fprintf( stdout, "%6s %3d %10d %10d %10d %10d %9.1f %10.1f 0x%.4X 0x%.8X %u:%.2u \r", "TRD :", rd0.trd, rd0.BlockWr, rd0.BlockRd, rd0.BlockOk, rd0.BlockError, rd0.VelocityCurrent, rd0.VelocityAvarage, status, sig, min, sec ); |
|
|
|
150,7 → 128,7
|
int WB_TestStrm::isComplete( void ) |
{ |
if( (lc_status==4) && (IsviStatus==100) ) |
if( lc_status==4 ) |
return 1; |
return 0; |
} |
157,13 → 135,37
|
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\nResult of receiving data \n" ); |
|
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 Recieved blocks : %d \n", rd0.BlockRd ); |
BRDC_fprintf( stderr, " Correct blocks : %d \n", rd0.BlockOk ); |
BRDC_fprintf( stderr, " Incorrect blocks: %d \n", rd0.BlockError ); |
BRDC_fprintf( stderr, " Total errors : %d \n\n", rd0.TotalError ); |
BRDC_fprintf( stderr, " Speed : %.1f [Mbytes/s] \n", rd0.VelocityAvarage ); |
|
long currentTime = GetTickCount(); |
int min, sec_all, sec; |
sec_all= currentTime-rd0.time_start; |
sec_all/=1000; |
sec=sec_all%60; |
min=sec_all/60; |
|
BRDC_fprintf( stderr, " Time of test : %d min %.2d sec\n\n", min, sec ); |
|
|
if(rd0.BlockRd!=0 && rd0.BlockError==0) |
{ |
BRDC_fprintf( stderr,"All data is correct. No error\n" ); |
} else if( rd0.BlockRd==0 ) |
{ |
BRDC_fprintf( stderr,"Error - data is not received \n" ); |
|
} else |
{ |
BRDC_fprintf( stderr,"List of error:\n" ); |
BRDC_fprintf( stderr,"%s\n", rd0.testBuf.report_word_error()); |
} |
|
BRDC_fprintf( stderr, "\n\n" ); |
} |
|
177,18 → 179,6
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 ) |
{ |
201,32 → 191,10
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" ); |
237,11 → 205,7
|
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; |
|
{ |
272,7 → 236,7
{ |
TF_WorkParam::ShowParam(); |
|
BRDC_fprintf( stderr, "Общий размер буфера стрима: %d МБ\n\n", SizeStreamOfBytes/(1024*1024) ); |
//BRDC_fprintf( stderr, "Size buffer: %d MB\n\n", SizeStreamOfBytes/(1024*1024) ); |
|
} |
|
281,20 → 245,6
{ |
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 ); |
*/ |
pBrd->wb_block_write( 1, 8, 1 ); |
|
pBrd->StreamStart( rd0.Strm ); |
310,13 → 260,23
BRDC_fprintf( stderr, "GEN_CTRL=0x%.4X \n", val ); |
|
pBrd->wb_block_write( 1, 8, 0 ); |
pBrd->wb_block_write( 1, 9, 1 ); |
pBrd->wb_block_write( 1, 8, 0x6A0 ); |
|
BlockMode = DataType <<8; |
BlockMode |= DataFix <<7; |
|
|
U32 size = SizeBlockOfWords/1024; |
//if( isTestCtrl ) |
{ |
pBrd->wb_block_write( 1, 9, size ); |
pBrd->wb_block_write( 1, 8, BlockMode | 0x20 ); |
} |
|
|
val=pBrd->wb_block_read( 1, 8 ); |
BRDC_fprintf( stderr, "GEN_CTRL=0x%.4X \n", val ); |
|
rd0.time_last=rd0.time_start=0 ;//GetTickCount(); |
rd0.time_last=rd0.time_start=GetTickCount(); |
|
|
for( ; ; ) |
329,10 → 289,7
ReceiveData( &rd0 ); |
//Sleep( 100 ); |
} |
/* |
pBrd->RegPokeInd( rd0.trd, 0, 2 ); |
Sleep( 200 ); |
*/ |
|
pBrd->StreamStop( rd0.Strm ); |
Sleep( 10 ); |
|
354,9 → 311,6
int ret; |
int kk; |
|
//pr->BlockRd++; |
//Sleep( 10 ); |
//return; |
|
for( kk=0; kk<16; kk++ ) |
{ |
363,13 → 317,11
ret=pBrd->StreamGetBuf( pr->Strm, &ptr ); |
//ret=0; |
if( ret ) |
{ // Проверка буфера стрима |
{ // check buffer |
|
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 ); |
395,8 → 347,7
} |
//Sleep( 0 ); |
|
/* |
U32 currentTime = GetTickCount(); |
long currentTime = GetTickCount(); |
if( (currentTime - pr->time_last)>4000 ) |
{ |
float t1 = currentTime - pr->time_last; |
413,12 → 364,7
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); |
*/ |
|
} |
|
425,7 → 371,7
|
void WB_TestStrm::PrepareWb( void ) |
{ |
|
/* |
BRDC_fprintf( stderr, "\nPrepare TEST_GENERATE\n" ); |
|
|
436,306 → 382,11
//if( isTestCtrl ) |
{ |
pBrd->wb_block_write( 1, 9, 1 ); |
pBrd->wb_block_write( 1, 9, BlockMode ); |
pBrd->wb_block_write( 1, 8, BlockMode ); |
} |
|
|
|
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, ®, &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" ); |
} |
|