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 2

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
    PrepareAdm();
68
 
69
    rd0.trd=trdNo;
70
    rd0.Strm=strmNo;
71
    pBrd->StreamInit( rd0.Strm, CntBuffer, SizeBuferOfBytes, rd0.trd, 1, isCycle, isSystem, isAgreeMode );
72
 
73
    bufIsvi = new U32[SizeBlockOfWords*2];
74
    //pBrd->StreamInit( strm, CntBuffer, SizeBuferOfBytes, rd0.trd, 1, 0, 0 );
75
}
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
    BRDC_fprintf( stderr, "%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 );
139
 
140
 
141
 
142
 
143
}
144
 
145
int WB_TestStrm::isComplete( void )
146
{
147
    if( (lc_status==4) && (IsviStatus==100) )
148
        return 1;
149
    return 0;
150
}
151
 
152
void WB_TestStrm::GetResult( void )
153
{
154
    //if(pkg_in.BlockRd!=0 && pkg_in.BlockError!=0)
155
    //  printf("%s\n", pkg_in.testBuf.report_word_error());
156
 
157
    BRDC_fprintf( stderr, "\n\nРезультат приёма данных через тетраду %d \n", trdNo );
158
    if(rd0.BlockRd!=0 && rd0.BlockError!=0)
159
        printf("%s\n", rd0.testBuf.report_word_error());
160
 
161
    BRDC_fprintf( stderr, "\n\n" );
162
}
163
 
164
void* WB_TestStrm::ThreadFunc( void* lpvThreadParm )
165
{
166
    WB_TestStrm *test=(WB_TestStrm*)lpvThreadParm;
167
    UINT ret;
168
    if( !test )
169
        return 0;
170
    ret=test->Execute();
171
    return (void*)ret;
172
}
173
 
174
void* WB_TestStrm::ThreadFuncIsvi( void* lpvThreadParm )
175
{
176
    WB_TestStrm *test=(WB_TestStrm*)lpvThreadParm;
177
    UINT ret;
178
    if( !test )
179
        return 0;
180
 
181
    Sleep( 200 );
182
    ret=test->ExecuteIsvi();
183
    return (void*)ret;
184
}
185
 
186
//! Установка параметров по умолчанию
187
void WB_TestStrm::SetDefault( void )
188
{
189
    int ii=0;
190
 
191
    array_cfg[ii++]=STR_CFG(  0, "CntBuffer",                    "16", (U32*)&CntBuffer, "число буферов стрима" );
192
    array_cfg[ii++]=STR_CFG(  0, "CntBlockInBuffer",     "512",  (U32*)&CntBlockInBuffer, "Число блоков в буфере" );
193
    array_cfg[ii++]=STR_CFG(  0, "SizeBlockOfWords",     "2048",  (U32*)&SizeBlockOfWords, "Размер блока в словах" );
194
    array_cfg[ii++]=STR_CFG(  0, "isCycle",                              "1",  (U32*)&isCycle, "1 - Циклический режим работы стрима" );
195
    array_cfg[ii++]=STR_CFG(  0, "isSystem",                     "1",  (U32*)&isSystem, "1 - выделение системной памяти" );
196
    array_cfg[ii++]=STR_CFG(  0, "isAgreeMode",                  "0",  (U32*)&isAgreeMode, "1 - согласованный режим" );
197
 
198
    array_cfg[ii++]=STR_CFG(  0, "trdNo",        "4",  (U32*)&trdNo, "Номер тетрады" );
199
    array_cfg[ii++]=STR_CFG(  0, "strmNo",       "0",  (U32*)&strmNo, "Номер стрма" );
200
    array_cfg[ii++]=STR_CFG(  0, "isTest",       "0",  (U32*)&isTest, "0 - нет, 1 - проверка псевдослучайной последовательности, 2 - проверка тестовой последовательности" );
201
    array_cfg[ii++]=STR_CFG(  0, "isMainTest",   "0",  (U32*)&isMainTest, "1 - включение режима тестирования в тетраде MAIN" );
202
 
203
    array_cfg[ii++]=STR_CFG(  0, "lowRange",     "0",  (U32*)&lowRange, "нижний уровень спектра" );
204
    array_cfg[ii++]=STR_CFG(  0, "topRange",     "0",  (U32*)&topRange, "верхний уровень спектра" );
205
    array_cfg[ii++]=STR_CFG(  0, "fftSize",      "2048",  (U32*)&fftSize, "размер БПФ" );
206
 
207
 
208
    fnameAdmReg=NULL;
209
    array_cfg[ii++]=STR_CFG(  2, "AdmReg",          "adcreg.ini",  (U32*)&fnameAdmReg, "имя файла регистров" );
210
 
211
    array_cfg[ii++]=STR_CFG(  0, "isAdmReg",     "0",  (U32*)&isAdmReg, "1 - разрешение записи регистров из файла AdmReg" );
212
 
213
    fnameAdmReg2=NULL;
214
    array_cfg[ii++]=STR_CFG(  2, "AdmReg2",         "adcreg2.ini",  (U32*)&fnameAdmReg2, "имя файла регистров (выполняется после старта стрима)" );
215
 
216
    array_cfg[ii++]=STR_CFG(  0, "isAdmReg2",    "0",  (U32*)&isAdmReg2, "1 - разрешение записи регистров из файла AdmReg2" );
217
 
218
    fnameIsvi=NULL;
219
    array_cfg[ii++]=STR_CFG(  2, "ISVI_FILE",   "",  (U32*)&fnameIsvi, "имя файла данных ISVI" );
220
 
221
    array_cfg[ii++]=STR_CFG(  0, "ISVI_HEADER",  "0",  (U32*)&IsviHeaderMode, "режим формирования суффикса ISVI, 0 - нет, 1 - DDC, 2 - ADC" );
222
 
223
 
224
    array_cfg[ii++]=STR_CFG(  0, "FifoRdy",              "0",  (U32*)&isFifoRdy, "1 - генератор тестовой последовательности анализирует флаг готовности FIFO" );
225
 
226
    array_cfg[ii++]=STR_CFG(  0, "Cnt1", "0",  (U32*)&Cnt1, "Число тактов записи в FIFO, 0 - постоянная запись в FIFO" );
227
 
228
    array_cfg[ii++]=STR_CFG(  0, "Cnt2", "0",  (U32*)&Cnt2, "Число тактов паузы при записи в FIFO" );
229
 
230
    array_cfg[ii++]=STR_CFG(  0, "DataType",     "0",  (U32*)&DataType, "Тип данных при фиксированном типе блока, 6 - счётчик, 8 - псевдослучайная последовательность" );
231
 
232
    array_cfg[ii++]=STR_CFG(  0, "DataFix",      "0",  (U32*)&DataFix, "1 - фиксированный тип блока, 0 - данные в блоке записят от номера блока" );
233
 
234
    array_cfg[ii++]=STR_CFG(  0, "isTestCtrl",   "0",  (U32*)&isTestCtrl, "1 - подготовка тетрады TEST_CTRL" );
235
 
236
 
237
    array_cfg[ii++]=STR_CFG(  0, "TestSeq",                      "0",  (U32*)&TestSeq, "Значение регистра TEST_SEQ" );
238
 
239
    max_item=ii;
240
 
241
    {
242
        char str[1024];
243
        for( unsigned ii=0; ii<max_item; ii++ )
244
        {
245
            sprintf( str, "%s  %s", array_cfg[ii].name, array_cfg[ii].def );
246
            GetParamFromStr( str );
247
        }
248
 
249
 
250
    }
251
 
252
}
253
 
254
//! Расчёт параметров
255
void WB_TestStrm::CalculateParams( void )
256
{
257
    SizeBlockOfBytes = SizeBlockOfWords * 4;                                            // Размер блока в байтах
258
    SizeBuferOfBytes    = CntBlockInBuffer * SizeBlockOfBytes  ;        // Размер буфера в байтах
259
    SizeStreamOfBytes   = CntBuffer * SizeBuferOfBytes;                         // Общий размер буфера стрима
260
 
261
    ShowParam();
262
}
263
 
264
//! Отображение параметров
265
void WB_TestStrm::ShowParam( void )
266
{
267
    TF_WorkParam::ShowParam();
268
 
269
    BRDC_fprintf( stderr, "Общий размер буфера стрима: %d МБ\n\n", SizeStreamOfBytes/(1024*1024) );
270
 
271
}
272
 
273
 
274
U32 WB_TestStrm::Execute( void )
275
{
276
    rd0.testBuf.buf_check_start( 32, 64 );
277
 
278
/*
279
    pBrd->RegPokeInd( rd0.trd, 0, 0x2010 );
280
    pBrd->StreamStart( rd0.Strm );
281
    pBrd->RegPokeInd( rd0.trd, 0, 0x2038 );
282
    if( isTestCtrl )
283
    {
284
        StartTestCtrl();
285
    }
286
 
287
    if( isAdmReg2 )
288
        PrepareAdmReg( fnameAdmReg2 );
289
 
290
    pBrd->RegPokeInd( 4, 0, 0x2038 );
291
*/
292
    rd0.time_last=rd0.time_start=0 ;//GetTickCount();
293
 
294
 
295
    for( ; ; )
296
    {
297
        if( Terminate )
298
        {
299
            break;
300
        }
301
 
302
        ReceiveData( &rd0 );
303
        //Sleep( 100 );
304
    }
305
/*
306
    pBrd->RegPokeInd( rd0.trd, 0, 2 );
307
    Sleep( 200 );
308
*/
309
    pBrd->StreamStop( rd0.Strm );
310
    Sleep( 10 );
311
 
312
    lc_status=4;
313
    return 1;
314
}
315
 
316
 
317
 
318
 
319
void WB_TestStrm::ReceiveData(  ParamExchange *pr )
320
{
321
    U32 *ptr;
322
    U32 *ptrBlock;
323
    U32 mode=0;
324
    mode |= pr->DataType<<8;
325
    mode |= pr->DataFix<<7;
326
 
327
    int ret;
328
    int kk;
329
 
330
    //pr->BlockRd++;
331
    //Sleep( 10 );
332
    //return;
333
 
334
    for( kk=0; kk<16; kk++ )
335
    {
336
        ret=pBrd->StreamGetBuf( pr->Strm, &ptr );
337
        if( ret )
338
        { // Проверка буфера стрима
339
 
340
                for( unsigned ii=0; ii<CntBlockInBuffer; ii++ )
341
                {
342
                    ptrBlock=ptr+ii*SizeBlockOfWords;
343
                    if( isIsvi )
344
                        IsviStep( ptrBlock );
345
 
346
                    if( 1==isTest )
347
                        pr->testBuf.buf_check_psd( ptrBlock, SizeBlockOfWords );
348
                    //int a=0;
349
                    else if( 2==isTest )
350
                        pr->testBuf.buf_check( ptrBlock, pr->BlockRd, SizeBlockOfWords, BlockMode );
351
                    else if( 4==isTest )
352
                        pr->testBuf.buf_check_inv( ptrBlock, SizeBlockOfWords );
353
 
354
                    pr->BlockRd++;
355
                }
356
                if( isAgreeMode )
357
                {
358
                    pBrd->StreamGetBufDone( pr->Strm );
359
                }
360
 
361
        } else
362
        {
363
            //Sleep( 0 );
364
            pr->freeCycle++;
365
            break;
366
        }
367
    }
368
    //Sleep( 0 );
369
 
370
/*
371
    U32 currentTime = GetTickCount();
372
    if( (currentTime - pr->time_last)>4000 )
373
    {
374
        float t1 = currentTime - pr->time_last;
375
        float t2 = currentTime - pr->time_start;
376
        float v = 1000.0*(pr->BlockRd-pr->BlockLast)*SizeBlockOfBytes/t1;
377
        v/=1024*1024;
378
        pr->VelocityCurrent=v;
379
 
380
        v = 1000.0*(pr->BlockRd)*SizeBlockOfBytes/t2;
381
        v/=1024*1024;
382
        pr->VelocityAvarage=v;
383
        pr->time_last = currentTime;
384
        pr->BlockLast = pr->BlockRd;
385
        pr->freeCycleZ=pr->freeCycle;
386
        pr->freeCycle=0;
387
 
388
        if(lowRange == 0)
389
            pr->testBuf.buf_check_sine_show();
390
        //pr->testBuf.buf_check_sine_calc_delta();
391
    }
392
    //Sleep(1);
393
*/
394
 
395
}
396
 
397
 
398
void WB_TestStrm::PrepareAdm( void )
399
{
400
/*
401
    U32 trd=trdNo;
402
    U32 id, id_mod, ver;
403
    BRDC_fprintf( stderr, "\nПодготовка тетрады\n" );
404
 
405
 
406
    id = pBrd->RegPeekInd( trd, 0x100 );
407
    id_mod = pBrd->RegPeekInd( trd, 0x101 );
408
    ver = pBrd->RegPeekInd( trd, 0x102 );
409
 
410
    //pBrd->RegPokeInd( trd, 0, 0x2038 );
411
 
412
    BRDC_fprintf( stderr, "\nТетрада %d  ID: 0x%.2X MOD: %d  VER: %d.%d \n\n",
413
            trd, id, id_mod, (ver>>8) & 0xFF, ver&0xFF );
414
 
415
 
416
    //if( fnameDDS )
417
    //  PrepareDDS();
418
 
419
 
420
    if( isMainTest )
421
        PrepareMain();
422
 
423
 
424
    BlockMode = DataType <<8;
425
    BlockMode |= DataFix <<7;
426
 
427
    if( isTestCtrl )
428
        PrepareTestCtrl();
429
 
430
    if( isAdmReg )
431
        PrepareAdmReg( fnameAdmReg );
432
 
433
 
434
    IsviStatus=0;
435
    IsviCnt=0;
436
    isIsvi=0;
437
    if( fnameIsvi )
438
    {
439
        IsviStatus=1;
440
        isIsvi=1;
441
    }
442
 
443
*/
444
}
445
 
446
 
447
 
448
 
449
//! Подготовка MAIN
450
void WB_TestStrm::PrepareMain( void )
451
{
452
/*
453
    if( 4==isTest )
454
    {
455
        BRDC_fprintf( stderr, "В тетраде MAIN установлен режим формирования двоично-инверсной последовательности\n" );
456
    } else
457
    {
458
        BRDC_fprintf( stderr, "В тетраде MAIN установлен режим формирования псевдослучайной последовательности\n" );
459
        pBrd->RegPokeInd( 0, 12, 1 );  // Регистр TEST_MODE[0]=1 - режим формирования псевдослучайной последовательности
460
    }
461
    pBrd->RegPokeInd( 0, 0, 2 );   // Сброс FIFO - перевод в начальное состояние
462
    Sleep( 1 );
463
    pBrd->RegPokeInd( 0, 0, 0 );
464
    Sleep( 1 );
465
*/
466
}
467
 
468
void WB_TestStrm::IsviStep( U32* ptr )
469
{
470
    unsigned ii;
471
    if( (1==IsviStatus) || (4==IsviStatus ) )
472
    {
473
        for( ii=0; ii<SizeBlockOfWords; ii++ ) bufIsvi[ii]=ptr[ii];
474
        IsviStatus++;
475
    }
476
}
477
 
478
void WB_TestStrm::WriteFlagSinc(int flg, int isNewParam)
479
{
480
    int fs = -1;
481
    int val[2];
482
 
483
    char fname[256];
484
    sprintf( fname, "%s.flg", fnameIsvi );
485
 
486
    while( fs==-1 )
487
    {
488
        fs = open( fname, O_RDWR|O_CREAT, 0666 );
489
        Sleep( 10 );
490
    }
491
    val[0] = flg;
492
    val[1] = isNewParam;
493
    write( fs, val, 8 );
494
    close( fs );
495
}
496
 
497
int  WB_TestStrm::ReadFlagSinc(void)
498
{
499
    int fs = -1;
500
    int flg;
501
 
502
    char fname[256];
503
    sprintf( fname, "%s.flg", fnameIsvi );
504
 
505
    while( fs==-1 )
506
    {
507
        fs = open( fname, O_RDWR|O_CREAT, 0666 );
508
        Sleep( 10 );
509
    }
510
    read( fs, &flg, 4 );
511
    close( fs );
512
 
513
    return flg;
514
}
515
 
516
void WB_TestStrm::WriteDataFile( U32 *pBuf, U32 sizew )
517
{
518
    char fname[256];
519
    sprintf( fname, "%s.bin", fnameIsvi );
520
    int     fl = open(fname, O_WRONLY|O_CREAT|O_TRUNC, 0666);
521
 
522
    if( fl==-1 )
523
    {
524
        return;
525
    }
526
 
527
 
528
    write( fl, pBuf, sizew*4 );
529
 
530
    write( fl, IsviHeaderStr, IsviHeaderLen );
531
 
532
    close( fl );
533
}
534
 
535
 
536
U32 WB_TestStrm::ExecuteIsvi( void )
537
{
538
    for( ; ; )
539
    {
540
        if( Terminate )
541
        {
542
            break;
543
        }
544
 
545
        int rr;
546
        switch( IsviStatus )
547
        {
548
        case 2: // Подготовка суффикса
549
            {
550
                IsviHeaderStr[0]=0;
551
                /*
552
                                        switch( IsviHeaderMode )
553
                                        {
554
                                                case 1:  SetFileHeaderDdc( SizeBlockOfWords, IsviHeaderStr ); break;
555
                                                case 2:  SetFileHeaderAdc( SizeBlockOfWords, IsviHeaderStr ); break;
556
                                        }
557
                                        */
558
                IsviHeaderLen = 0; //strlen( IsviHeaderStr );
559
                WriteFlagSinc(0,0);
560
                WriteDataFile( bufIsvi, SizeBlockOfWords );
561
                WriteFlagSinc(0xffffffff,0xffffffff);
562
 
563
                IsviCnt++;
564
                IsviStatus=3;
565
            }
566
            break;
567
 
568
        case 3:
569
            {
570
                rr=ReadFlagSinc();
571
                if( 0==rr )
572
                    IsviStatus=4;
573
 
574
            }
575
            break;
576
 
577
        case 4:
578
            // Ожидание получения данных
579
            Sleep( 100 );
580
            break;
581
 
582
        case 5:
583
            {
584
                WriteDataFile( bufIsvi, SizeBlockOfWords );
585
                WriteFlagSinc(0xffffffff,0 );
586
                IsviStatus=3;
587
                IsviCnt++;
588
            }
589
            break;
590
 
591
        }
592
 
593
        Sleep( 100 );
594
    }
595
    IsviStatus=100;
596
    return 0;
597
}
598
 
599
 
600
#define TRD_CTRL 1
601
 
602
#define REG_MUX_CTRL  0x0F
603
#define REG_GEN_CNT1  0x1A
604
#define REG_GEN_CNT2  0x1B
605
#define REG_GEN_CTRL  0x1E
606
#define REG_GEN_SIZE  0x1F
607
#define TRD_DIO_IN    6
608
#define TRD_CTRL      1
609
//#define TRD_DIO_IN
610
//! Подготовка TEST_CTRL
611
 
612
void WB_TestStrm::PrepareTestCtrl( void )
613
{
614
    BRDC_fprintf( stderr, "\nПодготовка тетрады TEST_CTRL\n" );
615
/*
616
    BlockMode = DataType <<8;
617
    BlockMode |= DataFix <<7;
618
 
619
    if( !isFifoRdy )
620
        BlockMode |=0x1000;
621
 
622
    U32 block_mode=BlockMode;
623
 
624
    pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CTRL, 1 );
625
 
626
    //U32 mode0=pBrd->RegPeekInd( TRD_DIO_IN, 0 );
627
    // pBrd->RegPokeInd( TRD_DIO_IN, 0, 2 );
628
 
629
    Sleep( 1 );
630
 
631
    //pBrd->RegPokeInd( TRD_DIO_IN, 0, 0 );
632
 
633
    pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CTRL, 0 );
634
 
635
    pBrd->RegPokeInd( TRD_CTRL, REG_MUX_CTRL, 1 );
636
 
637
    U32  val=SizeBlockOfBytes/4096;
638
 
639
    pBrd->RegPokeInd( TRD_CTRL, REG_GEN_SIZE, val );
640
 
641
    if( block_mode & 0x80 )
642
    {
643
        BRDC_fprintf( stderr, "Используется сокращённая тестовая последовательность\r\n" );
644
    } else
645
    {
646
        BRDC_fprintf( stderr, "Используется полная тестовая последовательность\r\n" );
647
    }
648
 
649
 
650
    if( Cnt1 || Cnt2 )
651
    {
652
        pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CNT1, Cnt1 );
653
        pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CNT2, Cnt2 );
654
        float sp=1907.348632812 * (Cnt1-1)/(Cnt1+Cnt2-2);
655
        BRDC_fprintf( stderr, "Установлено ограничение скорости формирования потока:  %6.1f МБайт/с \r\n"
656
                "REG_CNT1=%d  REGH_CNT2=%d   \r\n", sp, Cnt1, Cnt2 );
657
        if( block_mode&0x1000 )
658
        {
659
            BRDC_fprintf( stderr, "Установлен режим без ожидания готовности FIFO\r\n\r\n" );
660
        } else
661
        {
662
            BRDC_fprintf( stderr, "Установлено ожидание готовности FIFO \r\n\r\n"        );
663
        }
664
    }  else
665
    {
666
        pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CNT1, 0 );
667
        pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CNT2, 0 );
668
        BRDC_fprintf( stderr, "Установлено формирование потока на максимальной скорости: 1907 МБайт/с \r\n"
669
                "Установлено ожидание готовности FIFO \r\n\r\n"        );
670
    }
671
 
672
*/
673
}
674
 
675
//! Запуск TestCtrl
676
void WB_TestStrm::StartTestCtrl( void )
677
{
678
/*
679
    U32 ctrl=0x20;
680
    ctrl|=BlockMode;
681
    if( Cnt1 || Cnt2 )
682
        ctrl|=0x40;
683
 
684
    if( !isFifoRdy )
685
        ctrl |=0x1000;
686
    //  ctrl&= ~0x1000;
687
    //BRDC_fprintf( stderr, "TEST_CTRL: REG_GEN_CTRL = 0x%.4X \r\n", ctrl );
688
 
689
    pBrd->RegPokeInd( TRD_CTRL, REG_GEN_CTRL, ctrl );  // Запуск DIO_IN
690
 
691
    //U32 mode0=pBrd->RegPeekInd( 6, 0 );
692
    //mode0 |=0x30;
693
    //pBrd->RegPokeInd( 6, 0, mode0 );          // Запуск DIO_IN
694
*/
695
 
696
}
697
 
698
 
699
//! Запись регистров из файла
700
void WB_TestStrm::PrepareAdmReg( char* fname )
701
{
702
    BRDC_fprintf( stderr, "\nУстановка регистров из файла %s\r\n\n", fname );
703
/*
704
    FILE *in = fopen( fname, "rt" );
705
    if( in==NULL )
706
    {
707
        throw( "Ошибка доступа к файлу " );
708
    }
709
 
710
    char str[256];
711
    U32 trd, reg, val;
712
    int ret;
713
    for( ; ; )
714
    {
715
        if( fgets( str, 200, in )==NULL )
716
            break;
717
 
718
        if( str[0]==';' )
719
            continue;
720
 
721
        ret=sscanf( str, "%i %i %i", &trd, &reg, &val );
722
        if( 3==ret )
723
        {
724
            BRDC_fprintf( stderr, "  TRD: %d  REG[0x%.2X]=0x%.4X \n", trd, reg, val );
725
            pBrd->RegPokeInd( trd, reg, val );
726
        }
727
 
728
    }
729
*/
730
    BRDC_fprintf( stderr, "\n\n" );
731
}
732
 

powered by: WebSVN 2.1.0

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