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 19

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

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

powered by: WebSVN 2.1.0

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