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/] [adm_test/] [src/] [work/] [tf_teststrmout.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
#define _USE_MATH_DEFINES
4
 
5
#include <math.h>
6
#include <stdio.h>
7
#include <fcntl.h>
8
#include <pthread.h>
9
#include <sys/types.h>
10
#include <sys/stat.h>
11
 
12
#include "utypes.h"
13
//#include "useful.h"
14
#include "tf_teststrmout.h"
15
#include "cl_ambpex.h"
16
 
17
 
18
 
19
#define BUFSIZEPKG 62
20
 
21
#define TRDIND_MODE0                                    0x0
22
#define TRDIND_MODE1                                    0x9
23
#define TRDIND_MODE2                                    0xA
24
#define TRDIND_SPD_CTRL                                 0x204
25
#define TRDIND_SPD_ADDR                                 0x205
26
#define TRDIND_SPD_DATA                                 0x206
27
 
28
 
29
TF_TestStrmOut::TF_TestStrmOut( BRDCHAR* fname, CL_AMBPEX *fotr )
30
{
31
    lc_status=0;
32
 
33
    Terminate=0;
34
    BlockRd=0;
35
    BlockOk=0;
36
    BlockError=0;
37
    TotalError=0;
38
 
39
    pBrd=fotr;
40
 
41
    SetDefault();
42
    GetParamFromFile( fname );
43
    CalculateParams();
44
 
45
    isFirstCallStep=true;
46
 
47
    SetSignalInit();
48
}
49
 
50
TF_TestStrmOut::~TF_TestStrmOut()
51
{
52
    pBrd->StreamDestroy( tr0.Strm );
53
 
54
}
55
 
56
void TF_TestStrmOut::Prepare( void )
57
{
58
    PrepareAdm();
59
 
60
    tr0.trd=trdNo;
61
    tr0.Strm=strmNo;
62
    pBrd->StreamInit( tr0.Strm, CntBuffer, SizeBuferOfBytes, tr0.trd, 2, isCycle, isSystem, isAgreeMode );
63
 
64
}
65
 
66
void TF_TestStrmOut::Start( void )
67
{
68
    int res = pthread_attr_init(&attrThread_);
69
    if(res != 0) {
70
        fprintf(stderr, "%s\n", "Stream not started");
71
        return;
72
    }
73
 
74
    res = pthread_attr_setdetachstate(&attrThread_, PTHREAD_CREATE_JOINABLE);
75
    if(res != 0) {
76
        fprintf(stderr, "%s\n", "Stream not started");
77
        return;
78
    }
79
 
80
    res = pthread_create(&hThread, &attrThread_, ThreadFunc, this);
81
    if(res != 0) {
82
        fprintf(stderr, "%s\n", "Stream not started");
83
        return;
84
    }
85
}
86
 
87
void TF_TestStrmOut::Stop( void )
88
{
89
    if( isTest )
90
        TestCtrlStop( &tr0 );
91
 
92
    Terminate=1;
93
    lc_status=3;
94
}
95
 
96
void TF_TestStrmOut::Step( void )
97
{
98
    if( isTest )
99
        TestCtrlReadStatus( &tr0 );
100
 
101
    U32 status = pBrd->RegPeekDir( tr0.trd, 0 ) & 0xFFFF;
102
    BRDC_fprintf( stderr, "%6s %3d %10d %10d %10d %10d  %9.1f %10.1f     0x%.4X  \r", "TRD :", tr0.trd, tr0.BlockWr, tr0.BlockRd, tr0.BlockOk, tr0.BlockError, tr0.VelocityCurrent, tr0.VelocityAvarage, status );
103
}
104
 
105
int TF_TestStrmOut::isComplete( void )
106
{
107
    if( (lc_status==4)  )
108
        return 1;
109
    return 0;
110
}
111
 
112
void TF_TestStrmOut::GetResult( void )
113
{
114
    //if(pkg_in.BlockRd!=0 && pkg_in.BlockError!=0)
115
    //  printf("%s\n", pkg_in.testBuf.report_word_error());
116
 
117
    if( isTest )
118
    {
119
        BRDC_fprintf( stderr, "\n\nResult of transmitted data via tetrad %d \n", trdNo );
120
        TestCtrlResult( &tr0 );
121
    }
122
    BRDC_fprintf( stderr, "\n\n" );
123
}
124
 
125
void* TF_TestStrmOut::ThreadFunc( void*   lpvThreadParm )
126
{
127
    TF_TestStrmOut *test=(TF_TestStrmOut*)lpvThreadParm;
128
    UINT ret;
129
    if( !test )
130
        return 0;
131
    ret=test->Execute();
132
    return (void*)ret;
133
}
134
 
135
 
136
 
137
//! Установка параметров по умолчанию
138
void TF_TestStrmOut::SetDefault( void )
139
{
140
    int ii=0;
141
 
142
    array_cfg[ii++]=STR_CFG(  0, "CntBuffer",                    "16", (U32*)&CntBuffer, "число буферов стрима" );
143
    array_cfg[ii++]=STR_CFG(  0, "CntBlockInBuffer",     "512",  (U32*)&CntBlockInBuffer, "Число блоков в буфере" );
144
    array_cfg[ii++]=STR_CFG(  0, "SizeBlockOfWords",     "2048",  (U32*)&SizeBlockOfWords, "Размер блока в словах" );
145
    array_cfg[ii++]=STR_CFG(  0, "isCycle",                              "1",  (U32*)&isCycle, "1 - Циклический режим работы стрима" );
146
    array_cfg[ii++]=STR_CFG(  0, "isSystem",                     "0",  (U32*)&isSystem, "1 - выделение системной памяти" );
147
    array_cfg[ii++]=STR_CFG(  0, "isAgreeMode",                  "0",  (U32*)&isAgreeMode, "1 - согласованный режим" );
148
 
149
    array_cfg[ii++]=STR_CFG(  0, "trdNo",        "4",  (U32*)&trdNo, "Номер тетрады" );
150
    array_cfg[ii++]=STR_CFG(  0, "strmNo",       "0",  (U32*)&strmNo, "Номер стрма" );
151
    array_cfg[ii++]=STR_CFG(  0, "isSdram",      "0",  (U32*)&isSdram, "1 - тетрада SDRAM" );
152
    array_cfg[ii++]=STR_CFG(  0, "isTest",       "0",  (U32*)&isTest, "0 - нет, 1 - проверка псевдослучайной последовательности" );
153
 
154
    array_cfg[ii++]=STR_CFG(  0, "DataType",     "0",  (U32*)&tr0.DataType, "Тип данных при фиксированном типе блока, 6 - счётчик, 8 - псевдослучайная последовательность" );
155
 
156
    array_cfg[ii++]=STR_CFG(  0, "DataFix",      "0",  (U32*)&tr0.DataFix, "1 - фиксированный тип блока, 0 - данные в блоке записят от номера блока" );
157
 
158
 
159
 
160
    max_item=ii;
161
 
162
    {
163
        char str[1024];
164
        for( unsigned ii=0; ii<max_item; ii++ )
165
        {
166
            sprintf( str, "%s  %s", array_cfg[ii].name, array_cfg[ii].def );
167
            GetParamFromStr( str );
168
        }
169
 
170
 
171
    }
172
 
173
}
174
 
175
//! Расчёт параметров
176
void TF_TestStrmOut::CalculateParams( void )
177
{
178
    SizeBlockOfBytes = SizeBlockOfWords * 4;                                            // Размер блока в байтах
179
    SizeBuferOfBytes    = CntBlockInBuffer * SizeBlockOfBytes  ;        // Размер буфера в байтах
180
    SizeStreamOfBytes   = CntBuffer * SizeBuferOfBytes;                         // Общий размер буфера стрима
181
 
182
    ShowParam();
183
}
184
 
185
//! Отображение параметров
186
void TF_TestStrmOut::ShowParam( void )
187
{
188
    TF_WorkParam::ShowParam();
189
 
190
    BRDC_fprintf( stderr, "Total stream buffer size: %d МБ\n\n", SizeStreamOfBytes/(1024*1024) );
191
 
192
}
193
 
194
 
195
U32 TF_TestStrmOut::Execute( void )
196
{
197
    tr0.testBuf.buf_check_start( 32, 64 );
198
 
199
    { // Начальное заполнение кольцевого буфера
200
        U32 ii, kk, mode;
201
        U32 *ptr, *ptrBlock;
202
        mode = (tr0.DataFix << 7) | (tr0.DataType<<8);
203
        for( kk=0; kk<CntBuffer; kk++ )
204
        {
205
            ptr=pBrd->StreamGetBufByNum( tr0.Strm, kk );
206
            for( ii=0; ii<CntBlockInBuffer; ii++ )
207
            {
208
 
209
                ptrBlock=ptr+ii*SizeBlockOfWords;
210
 
211
                if( isTest )
212
                    tr0.testBuf.buf_set( ptrBlock, tr0.BlockWr, SizeBlockOfWords, mode );
213
                else
214
                    SetSignal( ptrBlock );
215
 
216
                tr0.BlockWr++;
217
 
218
            }
219
        }
220
 
221
        TestCtrlStart( &tr0 );
222
    }
223
 
224
 
225
 
226
 
227
    pBrd->RegPokeInd( tr0.trd, 0, 0x2030 );
228
 
229
 
230
    pBrd->StreamStart( tr0.Strm );
231
 
232
 
233
 
234
 
235
    tr0.BlockLast=tr0.BlockStart=tr0.BlockWr;
236
 
237
    pBrd->RegPokeInd( tr0.trd, 0, 0x2038 );
238
 
239
    Sleep( 100 );
240
 
241
 
242
 
243
    tr0.time_last=tr0.time_start=0;//GetTickCount();
244
 
245
 
246
    for( ; ; )
247
    {
248
        if( Terminate )
249
        {
250
            break;
251
        }
252
 
253
        SendData( &tr0 );
254
 
255
    }
256
    pBrd->RegPokeInd( tr0.trd, 0, 2 );
257
    Sleep( 200 );
258
 
259
    pBrd->StreamStop( tr0.Strm );
260
    Sleep( 10 );
261
 
262
 
263
    lc_status=4;
264
    return 1;
265
}
266
 
267
 
268
 
269
 
270
void TF_TestStrmOut::SendData(  ParamExchange *pr )
271
{
272
    U32 *ptr;
273
    U32 *ptrBlock;
274
    U32 mode=0;
275
    mode |= pr->DataType<<8;
276
    mode |= pr->DataFix<<7;
277
 
278
    int ret;
279
    int kk;
280
 
281
    //pr->BlockRd++;
282
    //Sleep( 10 );
283
    //return;
284
 
285
 
286
    for( kk=0; kk<16; kk++ )
287
    {
288
        ret=pBrd->StreamGetBuf( pr->Strm, &ptr );
289
        if( ret )
290
        { // Заполнение буфера стрима
291
            for( unsigned ii=0; ii<CntBlockInBuffer; ii++ )
292
            {
293
                ptrBlock=ptr+ii*SizeBlockOfWords;
294
 
295
                if( isTest )
296
                    pr->testBuf.buf_set( ptrBlock, pr->BlockWr, SizeBlockOfWords, mode );
297
                /*
298
                                else
299
                                        SetSignal( ptrBlock );
300
                                */
301
                pr->BlockWr++;
302
                if( isAgreeMode )
303
                {
304
                    pBrd->StreamGetBufDone( pr->Strm );
305
                }
306
 
307
            }
308
        } else
309
        {
310
            //Sleep( 0 );
311
            pr->freeCycle++;
312
            //break;
313
        }
314
    }
315
    //Sleep( 0 );
316
 
317
/*
318
    U32 currentTime = GetTickCount();
319
    if( (currentTime - pr->time_last)>4000 )
320
    {
321
        float t1 = currentTime - pr->time_last;
322
        float t2 = currentTime - pr->time_start;
323
        float v = 1000.0*(pr->BlockWr-pr->BlockLast)*SizeBlockOfBytes/t1;
324
        v/=1024*1024;
325
        pr->VelocityCurrent=v;
326
 
327
        v = 1000.0*(pr->BlockWr-pr->BlockStart)*SizeBlockOfBytes/t2;
328
        v/=1024*1024;
329
        pr->VelocityAvarage=v;
330
        pr->time_last = currentTime;
331
        pr->BlockLast = pr->BlockWr;
332
        pr->freeCycleZ=pr->freeCycle;
333
        pr->freeCycle=0;
334
 
335
    }
336
    //Sleep(1);
337
*/
338
 
339
}
340
 
341
 
342
void TF_TestStrmOut::PrepareAdm( void )
343
{
344
    U32 trd=trdNo;
345
    U32 id, id_mod, ver;
346
    BRDC_fprintf( stderr, "\nPrepare tetrade\n" );
347
 
348
 
349
    id = pBrd->RegPeekInd( trd, 0x100 );
350
    id_mod = pBrd->RegPeekInd( trd, 0x101 );
351
    ver = pBrd->RegPeekInd( trd, 0x102 );
352
 
353
 
354
    BRDC_fprintf( stderr, "\nTetrade %d  ID: 0x%.2X MOD: %d  VER: %d.%d \n\n",
355
            trd, id, id_mod, (ver>>8) & 0xFF, ver&0xFF );
356
}
357
 
358
 
359
//! Запуск проверки в тетраде TestCtrl
360
void TF_TestStrmOut::TestCtrlStart( ParamExchange *pr )
361
{
362
    U32 trd=1;
363
 
364
    U32 check_size=SizeBlockOfBytes/4096;
365
    U32 check_ctrl= (pr->DataFix<<7) | (pr->DataType<<8);
366
 
367
    pBrd->RegPokeInd( trd, 0x0F, 1 );
368
 
369
    pBrd->RegPokeInd( trd, 0x1C, 1 ); // Reset
370
    Sleep( 10 );
371
    pBrd->RegPokeInd( trd, 0x1C, 0 );
372
    Sleep( 10 );
373
    pBrd->RegPokeInd( trd, 0x1D, check_size );
374
    pBrd->RegPokeInd( trd, 0x1C, check_ctrl | 0x20 );
375
 
376
}
377
 
378
 
379
 
380
//! Остановка проверки в тетраде TestCtrl
381
void TF_TestStrmOut::TestCtrlStop( ParamExchange *pr )
382
{
383
    U32 trd=1;
384
 
385
    U32 check_ctrl= (pr->DataFix<<7) | (pr->DataType<<8);
386
 
387
    pBrd->RegPokeInd( trd, 0x1C, check_ctrl ); // Останов
388
}
389
 
390
//! Чтение текущего состояния тетрады TestCtrl
391
void TF_TestStrmOut::TestCtrlReadStatus( ParamExchange *pr )
392
{
393
    U32 trd=1;
394
    U32 block_rd, block_ok, block_error, total_error;
395
 
396
    U32 reg_l, reg_h;
397
 
398
    reg_l = pBrd->RegPeekInd( trd, 0x210 );
399
    reg_h = pBrd->RegPeekInd( trd, 0x211 );
400
    block_rd = (reg_l&0xFFFF) | (reg_h<<16);
401
 
402
    reg_l = pBrd->RegPeekInd( trd, 0x212 );
403
    reg_h = pBrd->RegPeekInd( trd, 0x213 );
404
    block_ok = (reg_l&0xFFFF) | (reg_h<<16);
405
 
406
    reg_l = pBrd->RegPeekInd( trd, 0x214 );
407
    reg_h = pBrd->RegPeekInd( trd, 0x215 );
408
    block_error = (reg_l&0xFFFF) | (reg_h<<16);
409
 
410
    reg_l = pBrd->RegPeekInd( trd, 0x216 );
411
    reg_h = pBrd->RegPeekInd( trd, 0x217 );
412
    total_error = (reg_l&0xFFFF) | (reg_h<<16);
413
 
414
    pr->BlockRd=block_rd;
415
    pr->BlockOk=block_ok;
416
    pr->BlockError=block_error;
417
    pr->TotalError=total_error;
418
 
419
 
420
 
421
}
422
 
423
 
424
//! Получение результата в тетраде TestCtrl
425
void TF_TestStrmOut::TestCtrlResult( ParamExchange *pr )
426
{
427
    U32 trd=1;
428
    U32 block_rd, block_ok, block_error, total_error;
429
 
430
    U32 reg_l, reg_h;
431
 
432
    reg_l = pBrd->RegPeekInd( trd, 0x210 );
433
    reg_h = pBrd->RegPeekInd( trd, 0x211 );
434
    block_rd = (reg_l&0xFFFF) | (reg_h<<16);
435
 
436
    reg_l = pBrd->RegPeekInd( trd, 0x212 );
437
    reg_h = pBrd->RegPeekInd( trd, 0x213 );
438
    block_ok = (reg_l&0xFFFF) | (reg_h<<16);
439
 
440
    reg_l = pBrd->RegPeekInd( trd, 0x214 );
441
    reg_h = pBrd->RegPeekInd( trd, 0x215 );
442
    block_error = (reg_l&0xFFFF) | (reg_h<<16);
443
 
444
    reg_l = pBrd->RegPeekInd( trd, 0x216 );
445
    reg_h = pBrd->RegPeekInd( trd, 0x217 );
446
    total_error = (reg_l&0xFFFF) | (reg_h<<16);
447
 
448
    pr->BlockRd=block_rd;
449
    pr->BlockOk=block_ok;
450
    pr->BlockError=block_error;
451
    pr->TotalError=total_error;
452
 
453
    BRDC_fprintf( stderr, "\n Recieved blocks : %d \n",  block_rd );
454
    BRDC_fprintf( stderr, " Valid blocks: %d \n", block_ok );
455
    BRDC_fprintf( stderr, " Invalid blocks: %d \n", block_error );
456
    BRDC_fprintf( stderr, " Total errors:      %d \n\n", total_error );
457
 
458
    if( total_error>0 )
459
    {
460
        BRDC_fprintf( stderr, " Error list:\n" );
461
        int cnt=total_error;
462
        if( cnt>16 )
463
            cnt=16;
464
 
465
        int ii;
466
        U32 block, adr, _adr;
467
        __int64 data_ex, data_in;
468
        __int64 r0, r1, r2, r3;
469
 
470
        BRDC_fprintf( stderr, "%5s %10s %10s %20s %20s   \n", "N", "Блок", "Адрес", "Ожидается", "Принято" );
471
        for( ii=0; ii<cnt; ii++ )
472
        {
473
            adr=(ii<<4) + 0; pBrd->RegPokeInd( trd, 0x218, adr ); r0 = pBrd->RegPeekInd( trd, 0x219 );
474
            adr=(ii<<4) + 1; pBrd->RegPokeInd( trd, 0x218, adr ); r1 = pBrd->RegPeekInd( trd, 0x219 );
475
            adr=(ii<<4) + 2; pBrd->RegPokeInd( trd, 0x218, adr ); r2 = pBrd->RegPeekInd( trd, 0x219 );
476
            adr=(ii<<4) + 3; pBrd->RegPokeInd( trd, 0x218, adr ); r3 = pBrd->RegPeekInd( trd, 0x219 );
477
            data_in = ((r3&0xFFFF)<<48) | ((r2&0xFFFF)<<32) | ((r1&0xFFFF)<<16) | (r0&0xFFFF);
478
 
479
            adr=(ii<<4) + 4; pBrd->RegPokeInd( trd, 0x218, adr ); r0 = pBrd->RegPeekInd( trd, 0x219 );
480
            adr=(ii<<4) + 5; pBrd->RegPokeInd( trd, 0x218, adr ); r1 = pBrd->RegPeekInd( trd, 0x219 );
481
            adr=(ii<<4) + 6; pBrd->RegPokeInd( trd, 0x218, adr ); r2 = pBrd->RegPeekInd( trd, 0x219 );
482
            adr=(ii<<4) + 7; pBrd->RegPokeInd( trd, 0x218, adr ); r3 = pBrd->RegPeekInd( trd, 0x219 );
483
            data_ex = ((r3&0xFFFF)<<48) | ((r2&0xFFFF)<<32) | ((r1&0xFFFF)<<16) | (r0&0xFFFF);
484
 
485
            adr=(ii<<4) + 8; pBrd->RegPokeInd( trd, 0x218, adr ); r0 = pBrd->RegPeekInd( trd, 0x219 );
486
            adr=(ii<<4) + 9; pBrd->RegPokeInd( trd, 0x218, adr ); r1 = pBrd->RegPeekInd( trd, 0x219 );
487
            _adr = ((r1&0xFFFF)<<16) | (r0&0xFFFF);
488
 
489
            adr=(ii<<4) + 10; pBrd->RegPokeInd( trd, 0x218, adr ); r0 = pBrd->RegPeekInd( trd, 0x219 );
490
            adr=(ii<<4) + 11; pBrd->RegPokeInd( trd, 0x218, adr ); r1 = pBrd->RegPeekInd( trd, 0x219 );
491
            block = ((r1&0xFFFF)<<16) | (r0&0xFFFF);
492
 
493
            //BRDC_fprintf( stderr, "%5d %10d %10d     %.16ll64X     %.16ll64X \n", ii, block, _adr, data_ex, data_in );
494
            BRDC_fprintf( stderr, "%5d %10d %10d     %.llX     %.llX \n", ii, block, _adr, (long long)data_ex, (long long)data_in );
495
        }
496
 
497
        BRDC_fprintf( stderr, "\n" );
498
    }
499
 
500
 
501
 
502
}
503
 
504
static U32 fa_data[4096];
505
 
506
//! Заполнение блока синусом
507
void TF_TestStrmOut::SetSignalInit( void )
508
{
509
    int ii;
510
    float v, arg;
511
    int   d;
512
    for( ii=0; ii<4096; ii++ )
513
    {
514
        arg=2*M_PI*ii/4096;
515
        v=10000*sin( arg );
516
        d=v;
517
        fa_data[ii]=d;
518
    }
519
 
520
    fa_cnt_re=0;
521
    fa_cnt_im=0x40000000;
522
    fa_inc_re=0x1000000;
523
    fa_inc_im=fa_inc_re;
524
 
525
}
526
 
527
 
528
//! Заполнение блока синусом
529
void TF_TestStrmOut::SetSignal( U32* ptr )
530
{
531
    int re, im;
532
    unsigned ii;
533
    int adr_re;
534
    int adr_im;
535
    U32 data;
536
    U32 *dst=ptr;
537
 
538
    fa_cnt_re=0;
539
    fa_cnt_im=0x40000000;
540
    fa_inc_re=0x4000000;
541
    fa_inc_im=fa_inc_re;
542
 
543
    U32 d=0x4000000/(SizeBlockOfWords/2);
544
 
545
    for( ii=0; ii<(SizeBlockOfWords); ii++ )
546
    {
547
        adr_re=(fa_cnt_re>>20) & 0x0FFF;
548
        adr_im=(fa_cnt_im>>20) & 0x0FFF;
549
        re=fa_data[adr_re];
550
        im=fa_data[adr_im];
551
        data = (im<<16) | (re&0xFFFF);
552
        *dst++=data;
553
 
554
        fa_cnt_re+=fa_inc_re;
555
        fa_cnt_im+=fa_inc_im;
556
 
557
        fa_inc_re-=d;
558
        fa_inc_im=fa_inc_re;
559
    }
560
 
561
 
562
}

powered by: WebSVN 2.1.0

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