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

Subversion Repositories pcie_ds_dma

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

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

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

powered by: WebSVN 2.1.0

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