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

powered by: WebSVN 2.1.0

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