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