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_teststrmout.cpp] - Blame information for rev 2

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

powered by: WebSVN 2.1.0

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