OpenCores
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
    from Rev 2 to Rev 6
    ↔ Reverse comparison
  •

Rev 2 → Rev 6

/adm_test/src/work/tf_teststrm.cpp
4,6 → 4,7
#include <fcntl.h>
#include <pthread.h>
#include <unistd.h>
#include <math.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <pthread.h>
10,7 → 11,6
#include "utypes.h"
#include "tf_teststrm.h"
#include "cl_ambpex.h"
//#include "useful.h"
 
#define BUFSIZEPKG 62
 
22,17 → 22,21
#define TRDIND_SPD_DATA 0x206
 
#define TRDIND_TESTSEQ 0x0C
#define TRDIND_CHAN 0x10
#define TRDIND_FSRC 0x13
#define TRDIND_GAIN 0x15
#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;
53,12 → 57,17
isFirstCallStep=true;
}
 
//-----------------------------------------------------------------------------
 
TF_TestStrm::~TF_TestStrm()
{
pBrd->StreamDestroy( rd0.Strm );
//delete bufIsvi; bufIsvi=NULL;
delete bufIsvi;
bufIsvi=NULL;
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::Prepare( void )
{
PrepareAdm();
66,12 → 75,12
rd0.trd=trdNo;
rd0.Strm=strmNo;
pBrd->StreamInit( rd0.Strm, CntBuffer, SizeBuferOfBytes, rd0.trd, 1, isCycle, isSystem, isAgreeMode );
//pBrd->StreamInit( rd0.Strm, CntBuffer, SizeBuferOfBytes, rd0.trd, 2, isCycle, isSystem, isAgreeMode );
 
bufIsvi = new U32[SizeBlockOfWords*2];
//pBrd->StreamInit( strm, CntBuffer, SizeBuferOfBytes, rd0.trd, 1, 0, 0 );
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::Start( void )
{
int res = pthread_attr_init(&attrThread_);
111,35 → 120,47
}
}
 
//-----------------------------------------------------------------------------
 
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 );
 
/*
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 );
*/
U32 status = pBrd->RegPeekDir( rd0.trd, 0 ) & 0xFFFF;
 
rd0.testBuf.check_result( &rd0.BlockOk , &rd0.BlockError, NULL, NULL, NULL );
U32 cnt_rd=rd0.BlockRd;
if( isRestart )
cnt_rd = cntRestart;
 
//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 );
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 );
 
U32 status = pBrd->RegPeekDir( rd0.trd, 0 ) & 0xFFFF;
BRDC_fprintf( stderr, "%6s %3d %10d %10d %10d %10d %9.1f %10.1f 0x%.4X %d %4d\r", "TRD :", rd0.trd, rd0.BlockWr, rd0.BlockRd, 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) )
147,12 → 168,11
return 0;
}
 
//-----------------------------------------------------------------------------
 
void TF_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 from tetrade %d \n", trdNo );
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());
 
159,6 → 179,8
BRDC_fprintf( stderr, "\n\n" );
}
 
//-----------------------------------------------------------------------------
 
void* TF_TestStrm::ThreadFunc( void* lpvThreadParm )
{
TF_TestStrm *test=(TF_TestStrm*)lpvThreadParm;
169,6 → 191,8
return (void*)ret;
}
 
//-----------------------------------------------------------------------------
 
void* TF_TestStrm::ThreadFuncIsvi( void* lpvThreadParm )
{
TF_TestStrm *test=(TF_TestStrm*)lpvThreadParm;
181,17 → 205,20
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, "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, "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, "Номер стрма" );
198,18 → 225,13
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( 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( 2, "AdmReg2", "adcreg2.ini", (U32*)&fnameAdmReg2, "имя файла регистров (выполняется после старта стрима)" );
 
array_cfg[ii++]=STR_CFG( 0, "isAdmReg2", "0", (U32*)&isAdmReg2, "1 - разрешение записи регистров из файла AdmReg2" );
 
218,9 → 240,8
 
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, "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" );
231,24 → 252,22
 
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" );
 
array_cfg[ii++]=STR_CFG( 0, "TestSeq", "0", (U32*)&TestSeq, "Значение регистра TEST_SEQ" );
 
max_item=ii;
 
{
char str[1024];
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 )
{
259,6 → 278,8
ShowParam();
}
 
//-----------------------------------------------------------------------------
 
//! Отображение параметров
void TF_TestStrm::ShowParam( void )
{
265,26 → 286,14
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 );
 
//U32 *buffer = pBrd->StreamGetBufByNum(rd0.Strm,0);
 
//fprintf(stderr, "%s(): buffer = %p\n", __FUNCTION__, buffer);
//getchar();
/*
for(u32 i=0; i<SizeBlockOfWords; i++) {
buffer[i] = 0x1;
}
*/
//Sleep( 100 );
//pBrd->RegPokeInd( 4, 0, 0x2038 );
 
pBrd->RegPokeInd( rd0.trd, 0, 0x2010 );
pBrd->StreamStart( rd0.Strm );
pBrd->RegPokeInd( rd0.trd, 0, 0x2038 );
293,8 → 302,9
StartTestCtrl();
}
 
if( isAdmReg2 )
if( isAdmReg2 ) {
PrepareAdmReg( fnameAdmReg2 );
}
 
pBrd->RegPokeInd( 4, 0, 0x2038 );
 
309,8 → 319,8
}
 
ReceiveData( &rd0 );
//Sleep( 100 );
}
 
pBrd->RegPokeInd( rd0.trd, 0, 2 );
Sleep( 200 );
 
318,12 → 328,14
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;
335,10 → 347,6
int ret;
int kk;
 
//pr->BlockRd++;
//Sleep( 10 );
//return;
 
for( kk=0; kk<16; kk++ )
{
ret=pBrd->StreamGetBuf( pr->Strm, &ptr );
345,35 → 353,37
if( ret )
{ // Проверка буфера стрима
 
for( unsigned ii=0; ii<CntBlockInBuffer; ii++ )
{
ptrBlock=ptr+ii*SizeBlockOfWords;
if( isIsvi )
IsviStep( ptrBlock );
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 );
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 );
//}
pr->BlockRd++;
}
if( isAgreeMode )
{
pBrd->StreamGetBufDone( pr->Strm );
}
if( (1==isRestart) && (pr->BlockRd==(CntBuffer*CntBlockInBuffer) ) )
{
RestartAdc();
}
 
} else
{
//Sleep( 0 );
} else {
 
pr->freeCycle++;
break;
}
}
//Sleep( 0 );
 
U32 currentTime = GetTickCount();
if( (currentTime - pr->time_last)>10 )
391,14 → 401,10
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 TF_TestStrm::PrepareAdm( void )
{
411,20 → 417,13
id_mod = pBrd->RegPeekInd( trd, 0x101 );
ver = pBrd->RegPeekInd( trd, 0x102 );
 
//pBrd->RegPokeInd( trd, 0, 0x2038 );
 
BRDC_fprintf( stderr, "\nTetrade %d ID: 0x%.2X MOD: %d VER: %d.%d \n\n",
trd, id, id_mod, (ver>>8) & 0xFF, ver&0xFF );
trd, id, id_mod, (ver>>8) & 0xFF, ver&0xFF );
 
 
//if( fnameDDS )
// PrepareDDS();
 
 
if( isMainTest )
PrepareMain();
 
 
BlockMode = DataType <<8;
BlockMode |= DataFix <<7;
 
434,7 → 433,6
if( isAdmReg )
PrepareAdmReg( fnameAdmReg );
 
 
IsviStatus=0;
IsviCnt=0;
isIsvi=0;
443,23 → 441,9
IsviStatus=1;
isIsvi=1;
}
/*
pBrd->RegPokeInd( trd, 25, 3 );
pBrd->RegPokeInd( trd, 16, 3 );
pBrd->RegPokeInd( trd, 0x13, 0);
pBrd->RegPokeInd( trd, 28, 0 );
*/
//pBrd->RegPokeInd( trd, 0x1B, 0x100 );
 
// pBrd->RegPokeInd( trdSdram, 0, 1 );
 
 
 
}
 
 
 
 
//-----------------------------------------------------------------------------
//! Подготовка MAIN
void TF_TestStrm::PrepareMain( void )
{
466,10 → 450,10
 
if( 4==isTest )
{
BRDC_fprintf( stderr, "В тетраде MAIN установлен режим формирования двоично-инверсной последовательности\n" );
BRDC_fprintf( stderr, "In tetrade MAIN set mode of binary-inversion sequence\n" );
} else
{
BRDC_fprintf( stderr, "В тетраде MAIN установлен режим формирования псевдослучайной последовательности\n" );
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 - перевод в начальное состояние
478,6 → 462,8
Sleep( 1 );
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::IsviStep( U32* ptr )
{
unsigned ii;
488,6 → 474,8
}
}
 
//-----------------------------------------------------------------------------
 
void TF_TestStrm::WriteFlagSinc(int flg, int isNewParam)
{
int fs = -1;
503,10 → 491,15
}
val[0] = flg;
val[1] = isNewParam;
write( fs, val, 8 );
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;
520,12 → 513,17
fs = open( fname, O_RDWR|O_CREAT, 0666 );
Sleep( 10 );
}
read( fs, &flg, 4 );
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];
538,13 → 536,20
}
 
write( fl, pBuf, sizew*4 );
int res = write( fl, pBuf, sizew*4 );
if(res < 0) {
BRDC_fprintf( stderr, "Error write ISVI data\r\n" );
}
 
write( fl, IsviHeaderStr, IsviHeaderLen );
res = write( fl, IsviHeaderStr, IsviHeaderLen );
if(res < 0) {
BRDC_fprintf( stderr, "Error write ISVI header\r\n" );
}
 
close( fl );
}
 
//-----------------------------------------------------------------------------
 
U32 TF_TestStrm::ExecuteIsvi( void )
{
559,32 → 564,32
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);
{
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;
}
IsviCnt++;
IsviStatus=3;
}
break;
 
case 3:
{
rr=ReadFlagSinc();
if( 0==rr )
IsviStatus=4;
{
rr=ReadFlagSinc();
if( 0==rr )
IsviStatus=4;
 
}
}
break;
 
case 4:
593,12 → 598,12
break;
 
case 5:
{
WriteDataFile( bufIsvi, SizeBlockOfWords );
WriteFlagSinc(0xffffffff,0 );
IsviStatus=3;
IsviCnt++;
}
{
WriteDataFile( bufIsvi, SizeBlockOfWords );
WriteFlagSinc(0xffffffff,0 );
IsviStatus=3;
IsviCnt++;
}
break;
 
}
609,9 → 614,9
return 0;
}
 
//-----------------------------------------------------------------------------
 
#define TRD_CTRL 1
 
#define REG_MUX_CTRL 0x0F
#define REG_GEN_CNT1 0x1A
#define REG_GEN_CNT2 0x1B
619,9 → 624,9
#define REG_GEN_SIZE 0x1F
#define TRD_DIO_IN 6
#define TRD_CTRL 1
//#define TRD_DIO_IN
 
//-----------------------------------------------------------------------------
//! Подготовка TEST_CTRL
 
void TF_TestStrm::PrepareTestCtrl( void )
{
BRDC_fprintf( stderr, "\nПодготовка тетрады TEST_CTRL\n" );
666,7 → 671,7
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 );
"REG_CNT1=%d REGH_CNT2=%d \r\n", sp, Cnt1, Cnt2 );
if( block_mode&0x1000 )
{
BRDC_fprintf( stderr, "Установлен режим без ожидания готовности FIFO\r\n\r\n" );
679,12 → 684,11
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" );
"Установлено ожидание готовности FIFO \r\n\r\n" );
}
 
 
}
 
//-----------------------------------------------------------------------------
//! Запуск TestCtrl
void TF_TestStrm::StartTestCtrl( void )
{
708,16 → 712,16
 
}
 
 
//-----------------------------------------------------------------------------
//! Запись регистров из файла
void TF_TestStrm::PrepareAdmReg( char* fname )
{
BRDC_fprintf( stderr, "\nУстановка регистров из файла %s\r\n\n", fname );
BRDC_fprintf( stderr, "\nSetting up ADM registers from file: %s\r\n\n", fname );
 
FILE *in = fopen( fname, "rt" );
if( in==NULL )
{
throw( "Ошибка доступа к файлу " );
throw( "Error file access" );
}
 
char str[256];
742,3 → 746,47
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 );
}
 
//-----------------------------------------------------------------------------
/adm_test/src/work/tf_teststrm.h
5,8 → 5,8
 
class CL_AMBPEX;
class TF_TestDDS;
class TF_Emac;
 
 
class TF_TestStrm : public TF_WorkParam, public TF_Test
{
 
96,7 → 96,6
//! Отображение параметров
virtual void ShowParam( void );
 
 
U32 Terminate;
U32 BlockRd;
U32 BlockOk;
103,14 → 102,14
U32 BlockError;
U32 TotalError;
 
U32 CntBuffer; // Число буферов стрима
U32 CntBuffer; // Число буферов стрима
U32 CntBlockInBuffer; // Число блоков в буфере
U32 SizeBlockOfWords; // Размер блока в словах
U32 SizeBlockOfBytes; // Размер блока в байтах
U32 SizeBuferOfBytes; // Размер буфера в байтах
U32 SizeStreamOfBytes; // Общий размер буфера стрима
U32 isCycle; // 1 - циклический режим работы стрима
U32 isSystem; // 1 - системная память
U32 isCycle; // 1 - циклический режим работы стрима
U32 isSystem; // 1 - системная память
U32 isAgreeMode; // 1 - согласованный режим
 
U32 trdNo; // номер тетрады
118,10 → 117,6
U32 isTest; // 1 - проверка псевдослучайной последовательности, 2 - проверка тестовой последовательности
U32 isMainTest; // 1 - включение режима тестирования в тетараде MAIN
 
U32 lowRange;
U32 topRange;
U32 fftSize;
 
U32 isFifoRdy; // 1 - генератор тестовой последовательности анализирует флаг готовности FIFO
U32 Cnt1; // Число тактов записи в FIFO, 0 - постоянная запись в FIFO
U32 Cnt2; // Число тактов паузы при записи в FIFO
158,35 → 153,29
U32 lc_status;
float cpuFreq;
 
ParamExchange rd0;
ParamExchange rd0;
 
 
 
//void SendPkg( ParamExchange *pr );
//void ReceivePkg( ParamExchange *pr );
//void SendData( ParamExchange *pr );
void ReceiveData( ParamExchange *pr );
 
U32 TestSeq; // Региср управления режимом формирования тестовой последовательности
 
void RestartAdc( void );
 
U32 isRestart; // 1 - перезапуск сбора после завершения заполнения буфера стрима
U32 cntRestart; // число перезапусков
 
U32 isSystemMonitor; //!< 1 - чтение данных системного монитора
 
private :
 
bool isFirstCallStep;
 
void PrepareAdm( void );
 
void PrepareAdmReg( char* fname );
 
 
//! Подготовка MAIN
void PrepareAdc( void );
void PrepareDac( void );
void RestartDac(void);
void PrepareMain( void );
 
//! Подготовка TEST_CTRL
void PrepareTestCtrl( void );
 
//! Запуск TestCtrl
void StartTestCtrl( void );
 
 
};
/adm_test/src/work/main.cpp
31,10 → 31,9
#include "tf_test.h"
#include "tf_teststrm.h"
#include "tf_teststrmout.h"
//#include "useful.h"
 
#define DEVICE_NAME "/dev/AMBPEXARM_DEVID0"
//#define DEVICE_NAME "/dev/AMBPEX50"
#define DEVICE_NAME "/dev/pexdrv0"
 
CL_AMBPEX *pBrd = NULL;
U32 isTwoTest=0;
static volatile int exit_flag = 0;
74,6 → 73,7
{
BRDC_fprintf( stderr, _BRDC("Module "DEVICE_NAME" successfuly opened\n") );
 
 
for( int trd=0; trd<8; trd++ )
pBrd->RegPokeInd( trd, 0, 1 );
 
85,6 → 85,7
pBrd->RegPokeInd( trd, 0, 0 );
 
 
 
} else
{
BRDC_fprintf( stderr, _BRDC("Error open module "DEVICE_NAME": ret=0x%.8X\n"), ret );
119,51 → 120,37
 
//int key;
int isFirstCallStep=1;
int isStopped = 0;
for( ; ; )
{
//if( kbhit() )
//{
//int key=getch();
if( exit_flag )
{
if( exit_flag )
{
if(!isStopped) {
pTest->Stop();
if( pTest2 )
if( pTest2 ) {
pTest2->Stop();
}
BRDC_fprintf( stderr, _BRDC("\n\nCancel\n") );
isStopped = 1;
}
/*
if( key=='i' )
{
pBrd->RegPokeInd( 4, TRDIND_DELAY_CTRL, 0x12 );
pBrd->RegPokeInd( 4, TRDIND_DELAY_CTRL, 0x10 );
g_DelayCnt--; BRDC_fprintf( stderr, "\n\ng_DelayCnt = %d ", g_DelayCnt );
}
}
 
if( key=='o' )
{
pBrd->RegPokeInd( 4, TRDIND_DELAY_CTRL, 0x13 );
pBrd->RegPokeInd( 4, TRDIND_DELAY_CTRL, 0x11 );
g_DelayCnt++; BRDC_fprintf( stderr, "\n\ng_DelayCnt = %d ", g_DelayCnt );
}
*/
//}
if( exit_flag )
{
if(isStopped) {
 
ret=pTest->isComplete();
if( ret )
{
if( pTest2 )
{
ret=pTest2->isComplete();
if( ret )
break;
} else
{
break;
if( pTest->isComplete() ) {
 
if( pTest2 ) {
if( pTest2->isComplete() )
break;
} else {
break;
}
}
}
 
}
 
//SetConsoleCursorPosition(hConsoleOut, rCursorPosition);
if( isFirstCallStep || isTwoTest )
{
 
184,18 → 171,14
if( isTwoTest )
BRDC_fprintf( stderr, "\n\n" );
 
Sleep( 400 );
Sleep( 1400 );
 
fflush( stdout );
 
if(exit_flag)
break;
}
pTest->GetResult();
if( pTest2 )
pTest2->GetResult();
 
 
delete pTest; pTest=NULL;
delete pTest2; pTest2=NULL;
 
209,7 → 192,7
BRDC_fprintf( stderr, _BRDC("Неизвестная ошибка выполнения программы\n") );
}
 
BRDC_fprintf( stderr, "\n Press any key\n" );
BRDC_fprintf( stderr, "Exit program\n" );
 
return 0;
}
/adm_test/src/Makefile
12,14 → 12,28
CC = $(CROSS_COMPILE)g++
LD = $(CROSS_COMPILE)g++
 
CFLAGS := -D__LINUX__ -O2 -Wall -I../../../driver/pexdrv -I../../../common/board -I../../../common/pex -I./work -I./utils
LFLAGS := -Wl -ldl -lrt -lpthread
SRCDIR := board pex work utils
INCDIR := . \
../../../driver/pexdrv \
../../../common/board \
../../../common/pex \
../../../common/utils \
../../../common/dac \
../../../common/adc \
../../../common/dma
INCLUDE := $(addprefix -I, $(INCDIR))
 
CFLAGS := -D__LINUX__ -O2 -Wall $(INCLUDE)
LFLAGS := -Wl -ldl -lrt -lpthread -lm
 
SRCFILE := $(wildcard *.cpp)
SRCFILE += $(wildcard ../../../common/board/*.cpp)
SRCFILE += $(wildcard ../../../common/pex/*.cpp)
SRCFILE += $(wildcard ../../../common/board/*.cpp)
SRCFILE += $(wildcard ./work/*.cpp)
SRCFILE += $(wildcard ./utils/*.cpp)
SRCFILE += $(wildcard ../../../common/utils/*.cpp)
#SRCFILE += $(wildcard ../../../common/dma/*.cpp)
#SRCFILE += $(wildcard ../../../common/adc/*.cpp)
#SRCFILE += $(wildcard ../../../common/dac/*.cpp)
SRCFILE += $(wildcard ./work/*.cpp)
OBJFILE := $(patsubst %.cpp,%.o, $(SRCFILE))
 
$(TARGET_NAME): $(OBJFILE)
/adm_test/bin/test_main.cfg
0,0 → 1,59
 
CntBuffer 8 ; число буферов стрима
 
CntBlockInBuffer 1 ; Число блоков в буфере
 
;SizeBlockOfWords 4096 ; Размер блока в словах 4KB
SizeBlockOfWords 262144 ; Размер блока в словах 1MB
;SizeBlockOfWords 1048576 ; Размер блока в словах 1MB
;SizeBlockOfWords 4194304 ; Размер блока в словах 4MB
 
isCycle 1 ; 1 - циклический режим работы стрима
 
isAgreeMode 1 ; 1 - согласованный режим работы
 
isSystem 1 ; 1 - системная память
 
 
isMainTest 1 ; 1 - включение режима тестирования в тетраде MAIN
 
isSdram 0 ; 1 - инициализация SDRAM
 
trdNo 0 ; Номер тетрады
 
strmNo 1 ; Номер стрима
 
isDDC 0 ; 2 - АЦП, 1 - DDC
 
ISVI_FILE data_main ; имя файла данных ISVI
 
;ISVI_HEADER 2 ; 2 - установка параметров для АЦП, 1 - для DDC
 
 
isTest 1 ; 0 - нет проверки
; 1 - проверка псевдослучайной последовательности
; 2 - проверка тестовой последовательности
; 4 - проверка двоично-инверсной последовательности
; 5 - проверка синусоидального сигнала с использованием БПФ и библиотеки IPP от Intel
 
FifoRdy 1 ; 1 - генератор тестовой последовательности анализирует флаг готовности FIFO
 
Cnt1 0 ; Число тактов записи в FIFO, 0 - постоянная запись в FIFO
 
Cnt2 0 ; Число тактов паузы при записи в FIFO
 
DataType 6 ; Тип данных при фиксированном типе блока, 6 - счётчик, 8 - псевдослучайная последовательность
 
DataFix 1 ; 1 - фиксированный тип блока, 0 - данные в блоке записят от номера блока
 
isTestCtrl 0 ; 1 - подготовка тетрады TEST_CTRL
 
isCheckLvds 1 ; 1 - проверка LVDS_FPGA
 
isEmac0 3 ; 1 - приём через EMAC0, 2 - передача через EMAC0, 3 - приём и передача через EMAC0
 
isEmac1 3 ; 1 - приём через EMAC1, 2 - передача через EMAC1, 3 - приём и передача через EMAC1
 
isSystemMonitor 1 ; 1 - чтение данных системного монитора
 
isCheckInOutControl 1 ; 1 - проверка сигналов in_control, out_control
/board_exam/main.cpp
1,6 → 1,6
 
#ifndef __PEX_H__
#include "pex_board.h"
#ifndef __BOARD_H__
#include "board.h"
#endif
 
#include <cassert>
10,6 → 10,7
#include <iomanip>
#include <climits>
#include <cstdio>
#include <dlfcn.h>
 
//-----------------------------------------------------------------------------
 
16,58 → 17,136
using namespace std;
 
//-----------------------------------------------------------------------------
#define NUM_BLOCK 4
#define BLOCK_SIZE 0x1000
#define NUM_BLOCK 8
#define BLOCK_SIZE 0x10000
//-----------------------------------------------------------------------------
 
int main(int argc, char *argv[])
{
if(argc == 1) {
std::cerr << "usage: %s <device name>" << argv[0] << endl;
if(argc != 3) {
std::cerr << "usage: " << argv[0] << " <libname.so> </dev/devname>" << endl;
return -1;
}
 
std ::cout << "Start testing device " << argv[1] << endl;
 
char *libname = argv[1];
char *devname = argv[2];
int dmaChan = 0;
void* pBuffers[NUM_BLOCK] = {NULL};
void* pBuffers[NUM_BLOCK] = {NULL,NULL,NULL,NULL};
void *hlib = NULL;
board_factory factory = NULL;
board *brd = NULL;
u32 *buffer = NULL;
 
board *brd = new pex_board();
brd->brd_open(argv[1]);
std ::cout << "Loading library: " << libname << endl;
 
hlib = dlopen(libname, RTLD_LAZY);
if(!hlib) {
fprintf(stderr, "%s\n", dlerror());
return -1;
}
 
factory = (board_factory)dlsym(hlib, "create_board");
if(!factory) {
fprintf(stderr, "%s\n", dlerror());
dlclose(hlib);
return -1;
}
 
std ::cout << "Start testing device " << devname << endl;
 
brd = factory();
if(!brd) {
dlclose(hlib);
return -1;
}
 
if(brd->brd_open(devname) < 0) {
 
delete brd;
 
if(hlib) {
int res = dlclose(hlib);
if(res < 0) {
fprintf(stderr, "%s\n", dlerror());
return -1;
}
}
 
return -1;
}
 
brd->brd_init();
brd->brd_pld_info();
 
std::cout << "Reset FPGA..." << std::endl;
brd->brd_reg_poke_ind(0,0,1);
brd->brd_delay(100);
brd->brd_reg_poke_ind(0,0,0);
brd->brd_delay(100);
 
std::cout << "Init FPGA..." << std::endl;
for( int trd=0; trd<8; trd++ ) {
brd->brd_reg_poke_ind( trd, 0, 1 );
}
for( int trd=0; trd<8; trd++ ) {
for( int ii=1; ii<32; ii++ ) {
brd->brd_reg_poke_ind( trd, ii, 0 );
}
}
for( int trd=0; trd<8; trd++ ) {
brd->brd_reg_poke_ind( trd, 0, 0 );
}
 
std ::cout << "Press enter to allocate DMA memory..." << endl;
getchar();
 
int DmaChan = 1;
 
// Check BRDSHELL DMA interface
BRDctrl_StreamCBufAlloc sSCA = {
1, //dir
1,
1,
NUM_BLOCK,
BLOCK_SIZE,
&pBuffers[0],
pBuffers,
NULL,
};
 
brd->dma_alloc(dmaChan, &sSCA);
 
brd->dma_set_local_addr(DmaChan, 0x1000);
brd->dma_stop(DmaChan);
brd->dma_reset_fifo(DmaChan);
brd->dma_reset_fifo(DmaChan);
 
std ::cout << "Press enter to start DMA channel..." << endl;
getchar();
 
// fill data buffers
for(int j=0; j<NUM_BLOCK; j++) {
buffer = (u32*)pBuffers[j];
for(unsigned i=0; i<32; i++) {
buffer[i] = 0xAA556677;
}
}
 
brd->dma_start(dmaChan, 0);
 
std ::cout << "Press enter to stop DMA channel..." << endl;
getchar();
 
 
brd->dma_stop(dmaChan);
 
std ::cout << "Press enter to view DMA data (buffer 0)..." << endl;
getchar();
// show data buffers
for(int j=0; j<NUM_BLOCK; j++) {
 
u32 *buffer = (u32*)pBuffers[0];
for(unsigned i=0; i<BLOCK_SIZE/4; i+=128) {
std::cout << hex << buffer[i] << " ";
std ::cout << "DMA data buffer " << j << ":" << endl;
buffer = (u32*)pBuffers[j];
for(unsigned i=0; i<32; i++) {
std::cout << hex << buffer[i] << " ";
}
std ::cout << endl;
}
std::cout << dec << endl;
 
75,19 → 154,18
getchar();
 
brd->dma_free_memory(dmaChan);
/*
for(int i=0; i<16; i++)
std ::cout << "BAR0[" << i << "] = 0x" << hex << brd->brd_bar0_read(i) << dec << endl;
 
fprintf(stderr, "Press enter to read BAR1...\n");
getchar();
 
for(int i=0; i<16; i++)
std ::cout << "BAR1[" << i << "] = 0x" << hex << brd->brd_bar1_read(i) << dec << endl;
*/
brd->brd_close();
 
delete brd;
 
if(hlib) {
int res = dlclose(hlib);
if(res < 0) {
fprintf(stderr, "%s\n", dlerror());
return -1;
}
}
 
return 0;
}
/board_exam/Makefile
1,6 → 1,3
#
#change this makefile for your target...
#
 
PHONY = clean
TARGET_NAME = pex_board_test
7,21 → 4,31
 
all: $(TARGET_NAME)
 
ROOT_DIR = $(shell pwd)
BINPATH := ../..
BINDIR := $(BINPATH)/bin
LIBPATH := ../..
LIBDIR := $(LIBPATH)/lib
 
CC = $(CROSS_COMPILE)g++
LD = $(CROSS_COMPILE)g++
CC := $(CROSS_COMPILE)g++
LD := $(CROSS_COMPILE)g++
 
CFLAGS := -D__LINUX__ -g -Wall -I../../driver/pexdrv -I../../common/board -I../../common/pex -I../adm_test/src/utils
LFLAGS := -Wl
SRCDIR := ../../common/board ../../common/pex
#SRCFILE := $(wildcard *.cpp) $(wildcard $(SRCDIR)/*.cpp)
SRCFILE := $(wildcard *.cpp) $(wildcard ../../common/board/*.cpp)
SRCFILE += $(wildcard *.cpp) $(wildcard ../../common/pex/*.cpp)
OBJFILE := $(patsubst %.cpp,%.o, $(SRCFILE))
INCDIR := . \
../../driver/pexdrv \
../../common/board \
../../common/utils
 
$(TARGET_NAME): $(OBJFILE)
$(LD) $(LFLAGS) $(notdir $^) -o $(TARGET_NAME)
INCLUDE := $(addprefix -I, $(INCDIR))
 
#CFLAGS := -D__linux__ -D__VERBOSE__ -g -Wall $(INCLUDE)
CFLAGS := -D__linux__ -O2 -Wall $(INCLUDE)
LFLAGS := -Wl,-rpath $(LIBDIR) -L"$(LIBDIR)" -lboard -ldl -lpthread
 
#EXTFILES := ../common/net/net_board.cpp
#EXTFILES := ../common/net/netcmn.cpp
 
$(TARGET_NAME): $(patsubst %.cpp,%.o, $(wildcard *.cpp)) $(EXTFILES)
$(LD) -o $(TARGET_NAME) $(notdir $^) $(LFLAGS)
cp $(TARGET_NAME) $(BINDIR)
rm -f *.o *~ core
 
%.o: %.cpp
30,6 → 37,9
include $(wildcard *.d)
 
 
test:
@echo $(SRC)
 
clean:
rm -f *.o *~ core
rm -f *.d *~ core
39,7 → 49,3
rm -f *.o *~ core
rm -f *.d *~ core
rm -f $(TARGET_NAME)
 
src:
@echo $(SRCFILE)
@echo $(OBJFILE)
/wb_test/src/Makefile
12,12 → 12,28
CC = $(CROSS_COMPILE)g++
LD = $(CROSS_COMPILE)g++
 
CFLAGS := -D__LINUX__ -g -Wall -I./board -I./pex -I./work -I./utils
LFLAGS := -Wl -ldl -lrt -lpthread
SRCDIR := board pex work utils
#SRCFILE := $(wildcard *.cpp) $(wildcard $(SRCDIR)/*.cpp)
INCDIR := . \
../../../driver/pexdrv \
../../../common/board \
../../../common/pex \
../../../common/utils \
../../../common/dac \
../../../common/adc \
../../../common/dma
INCLUDE := $(addprefix -I, $(INCDIR))
 
CFLAGS := -D__LINUX__ -O2 -Wall $(INCLUDE)
LFLAGS := -Wl -ldl -lrt -lpthread -lm
 
SRCFILE := $(wildcard *.cpp)
SRCFILE += $(wildcard pex/*.cpp) $(wildcard board/*.cpp) $(wildcard work/*.cpp) $(wildcard utils/*.cpp)
SRCFILE += $(wildcard ../../../common/board/*.cpp)
SRCFILE += $(wildcard ../../../common/pex/*.cpp)
SRCFILE += $(wildcard ../../../common/utils/*.cpp)
#SRCFILE += $(wildcard ../../../common/dma/*.cpp)
#SRCFILE += $(wildcard ../../../common/adc/*.cpp)
#SRCFILE += $(wildcard ../../../common/dac/*.cpp)
SRCFILE += $(wildcard ./work/*.cpp)
OBJFILE := $(patsubst %.cpp,%.o, $(SRCFILE))
 
$(TARGET_NAME): $(OBJFILE)

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.