SIMULINK_ADC  1.0
Приём данных от АЦП
adc_ctrl.cpp
Go to the documentation of this file.
1 
2 #include "adc_ctrl.h"
3 #include "mu_ctrl.h"
4 
5 #include <math.h>
6 
7 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
8  #include <string.h>
9  #include "gipcy.h"
10 IPC_handle* g_hBufFileMap = NULL;
11 IPC_handle g_hFlgFileMap = NULL;
12 IPC_handle g_hPostfixFileMap = NULL;
13 #else
14  #include <conio.h>
15  #include <process.h>
16 HANDLE* g_hBufFileMap = NULL;
17 HANDLE g_hFlgFileMap = NULL;
18 HANDLE g_hPostfixFileMap = NULL;
19 #endif
20 
21 extern int g_fileMap;
22 ULONG* g_pFlags;
23 char* g_pPostfix;
24 
25 BRDctrl_StreamCBufAlloc g_buf_dscr;
26 extern BRD_Handle g_hSRV;
27 extern ULONG g_MemAsFifo;
28 extern ULONG g_AdcDrqFlag;
29 extern ULONG g_MemDrqFlag;
30 extern double g_samplRate;
31 extern int g_IoDelay;
32 
33 extern BRDCHAR g_AdcSrvName[]; // с номером службы
34 extern ULONG g_Cycle;
35 extern unsigned long long g_samplesOfChannel;
36 extern unsigned long long g_bBufSize;
37 extern int g_DirWriteFile;
38 extern ULONG g_FileBufSize;
39 
40 extern int g_transRate;
41 
42 extern int g_PretrigMode;
43 //long long g_nPreTrigSamples = 16;
44 extern long long g_nPostTrigSamples;
45 
46 void MappingIsviParams(BRD_Handle hADC, unsigned long long nNumberOfBytes);
47 
48 //void DisplayError(S32 status, BRDCHAR* func_name, BRDCHAR* cmd_str)
49 void DisplayError(S32 status, const char* func_name, const BRDCHAR* cmd_str)
50 {
51  S32 real_status = BRD_errext(status);
52  BRDCHAR msg[255];
53  switch(real_status)
54  {
55  case BRDerr_OK:
56  BRDC_sprintf(msg, _BRDC("%s - %s: BRDerr_OK\n"), func_name, cmd_str);
57  break;
58  case BRDerr_BAD_MODE:
59  BRDC_sprintf(msg, _BRDC("%s - %s: BRDerr_BAD_MODE\n"), func_name, cmd_str);
60  break;
61  case BRDerr_INSUFFICIENT_SERVICES:
62  BRDC_sprintf(msg, _BRDC("%s - %s: BRDerr_INSUFFICIENT_SERVICES\n"), func_name, cmd_str);
63  break;
64  case BRDerr_BAD_PARAMETER:
65  BRDC_sprintf(msg, _BRDC("%s - %s: BRDerr_BAD_PARAMETER\n"), func_name, cmd_str);
66  break;
67  case BRDerr_BUFFER_TOO_SMALL:
68  BRDC_sprintf(msg, _BRDC("%s - %s: BRDerr_BUFFER_TOO_SMALL\n"), func_name, cmd_str);
69  break;
70  case BRDerr_WAIT_TIMEOUT:
71  BRDC_sprintf(msg, _BRDC("%s - %s: BRDerr_WAIT_TIMEOUT\n"), func_name, cmd_str);
72  break;
73  default:
74  BRDC_sprintf(msg, _BRDC("%s - %s: Unknown error, status = %8X\n"), func_name, cmd_str, real_status);
75  break;
76  }
77  BRDC_printf(_BRDC("%s"), msg);
78 }
79 
80 // проверка, есть ли тактовая частота, выполняется для служб:
81 // ADC28X800M, ADC28X1G, ADC10X2G, ADC210X1G, ADC212X1G, FM814X125M
82 int CheckClock(BRD_Handle hADC, BRDCHAR* AdcSrvName)
83 {
84  if(BRDC_stricmp(AdcSrvName, _BRDC("ADC28X800M")) &&
85  BRDC_stricmp(AdcSrvName, _BRDC("ADC28X1G")) &&
86  BRDC_stricmp(AdcSrvName, _BRDC("ADC10X2G")) &&
87  BRDC_stricmp(AdcSrvName, _BRDC("ADC210X1G")) &&
88  BRDC_stricmp(AdcSrvName, _BRDC("ADC212X1G")) &&
89  BRDC_stricmp(AdcSrvName, _BRDC("FM814X125M"))
90  )
91  return 1; // если ни одна из этих служб
92  BRDC_printf(_BRDC("Clock checking...\r"));
93 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
94  IPC_delay(1000);
95 #else
96  Sleep(1000);
97 #endif
98  ULONG status = 1;
99  if(hADC)
100  {
101  for(int i = 0; i < 3; i++)
102  {
103  BRD_ClkMode clk_mode;
104  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_GETCLKMODE, &clk_mode);
105  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_SETCLKMODE, &clk_mode);
106 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
107  IPC_delay(10);
108 #else
109  Sleep(10);
110 #endif
111  ULONG fifo_status;
112  BRD_ctrl(hADC, 0, BRDctrl_ADC_FIFOSTATUS, &fifo_status);
113  if(fifo_status & 0x1000)
114  {
115  status = 1;
116  break;
117  }
118  else
119  status = 0;
120  }
121  }
122  BRDC_printf(_BRDC(" \r"));
123  if(status)
124  BRDC_printf(_BRDC("Clock is OK\n"));
125  else
126  BRDC_printf(_BRDC("Clock error\n"));
127  return status;
128 }
129 
130 S32 AdcSettings(BRD_Handle hADC, int idx, BRDCHAR* srvName, BRDCHAR* iniFileName)
131 {
132  S32 status;
133 
134  //ULONG master = BRDims_SINGLE; // реализован только независимый (одиночный) режим
135  //status = BRD_ctrl(hADC, 0, BRDctrl_ADC_SETMASTER, &master);
136 
137  BRD_AdcCfg adc_cfg;
138  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_GETCFG, &adc_cfg);
139  BRDC_printf(_BRDC("ADC Config: FIFO size = %d kBytes\n"), adc_cfg.FifoSize / 1024);
140 
141  //ULONG chan_mask = 3; // включаем оба канала
142  //status = BRD_ctrl(hADC, 0, BRDctrl_ADC_SETCHANMASK, &chan_mask);
143  //int num_chan = (chan_mask & 0x1) + ((chan_mask >> 1) & 0x1);
144 
145  // задать параметры из файла
146  BRDCHAR iniFilePath[MAX_PATH];
147  BRDCHAR iniSectionName[MAX_PATH];
148 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
149  IPC_getCurrentDir(iniFilePath, sizeof(iniFilePath)/sizeof(BRDCHAR));
150 #else
151  GetCurrentDirectory(sizeof(iniFilePath)/sizeof(BRDCHAR), iniFilePath);
152 #endif
153  BRDC_strcat(iniFilePath, iniFileName);
154  BRDC_sprintf(iniSectionName, _BRDC("device%d_%s%d"), idx, srvName, 0);
155 
156 #ifdef _ADM214X200M
157  BRD_AdcSpec adcSpec;
158  adcSpec.command = ADC214X200Mcmd_SETMU;
159  adcSpec.arg= (PVOID)&mu_dflt;
160  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_SETSPECIFIC, &adcSpec);
161  if(!BRD_errcmp(status, BRDerr_OK))
162  DisplayError(status, __FUNCTION__, _BRDC("ADC214X200Mcmd_SETMU"));
163 #else
164  #ifdef _ADM216X100M
165  BRD_AdcSpec adcSpec;
166  adcSpec.command = ADC216X100Mcmd_SETMU;
167  adcSpec.arg= (PVOID)&mu_dflt;
168  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_SETSPECIFIC, &adcSpec);
169  if(!BRD_errcmp(status, BRDerr_OK))
170  DisplayError(status, __FUNCTION__, _BRDC("ADC216X100Mcmd_SETMU"));
171  #else
172  #ifdef _ADM214X400M
173  BRD_AdcSpec adcSpec;
174  adcSpec.command = ADC214X400Mcmd_SETMU;
175  adcSpec.arg= (PVOID)&mu_dflt;
176  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_SETSPECIFIC, &adcSpec);
177  if(!BRD_errcmp(status, BRDerr_OK))
178  DisplayError(status, __FUNCTION__, _BRDC("ADC214X400Mcmd_SETMU"));
179  #else
180  #ifdef _FM412X500M
181  BRD_AdcSpec adcSpec;
182  adcSpec.command = FM412X500Mcmd_SETMU;
183  adcSpec.arg= (PVOID)&mu_dflt;
184  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_SETSPECIFIC, &adcSpec);
185  if(!BRD_errcmp(status, BRDerr_OK))
186  DisplayError(status, __FUNCTION__, _BRDC("FM412X500Mcmd_SETMU"));
187  #else
188  BRD_IniFile ini_file;
189  BRDC_strcpy(ini_file.fileName, iniFilePath);
190  BRDC_strcpy(ini_file.sectionName, iniSectionName);
191  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_READINIFILE, &ini_file);
192  #endif
193  #endif
194  #endif
195 #endif
196 
197  // получить источник и значение тактовой частоты можно отдельной функцией
198  BRD_SyncMode sync_mode;
199  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_GETSYNCMODE, &sync_mode);
200  if(BRDC_strstr(srvName, _BRDC("ADC1624X192")) ||
201  BRDC_strstr(srvName, _BRDC("ADC1624X128")) ||
202  BRDC_strstr(srvName, _BRDC("ADC818X800")))
203  {
204  if(BRD_errcmp(status, BRDerr_OK))
205  BRDC_printf(_BRDC("BRDctrl_ADC_GETSYNCMODE: source = %d, value = %.2f MHz, rate = %.3f kHz\n"),
206  sync_mode.clkSrc, sync_mode.clkValue/1000000, sync_mode.rate/1000);
207  else
208  DisplayError(status, __FUNCTION__, _BRDC("BRDctrl_ADC_GETSYNCMODE"));
209  }
210  else
211  {
212  if(BRD_errcmp(status, BRDerr_OK))
213  BRDC_printf(_BRDC("BRDctrl_ADC_GETSYNCMODE: source = %d, value = %.4f MHz, rate = %.4f MHz\n"),
214  sync_mode.clkSrc, sync_mode.clkValue/1000000, sync_mode.rate/1000000);
215  else
216  DisplayError(status, __FUNCTION__, _BRDC("BRDctrl_ADC_GETSYNCMODE"));
217  }
218  g_samplRate = sync_mode.rate;
219  // получить параметры стартовой синхронизации
220  // команда BRDctrl_ADC_GETSTARTMODE может получать 2 разные структуры
221  // для определения какую из них использует данная служба применяем трюк с массивом )))
222  U08 start_struct[40]; // наибольшая из структур имеет размер 40 байт
223  memset(start_struct, 0x5A, 40);
224  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_GETSTARTMODE, &start_struct);
225  if(BRD_errcmp(status, BRDerr_OK))
226  {
227  if(start_struct[39] == 0x5A)
228  { // стартовая схема на базовом модуле (используется структура по-меньше)
229  // службы: ADC414X65M, ADC216X100M, ADC1624X192, ADC818X800, ADC1612X1M
230  BRD_StartMode* start = (BRD_StartMode*)start_struct;
231  BRDC_printf(_BRDC("BRDctrl_ADC_GETSTARTMODE: start source = %d\n"), start->startSrc);
232 // if(start->startSrc == BRDsts_CMP0 || start->startSrc == BRDsts_CMP1)
233 // { // старт от компаратора 0 (сигнал канала 0) или от компаратора 1 (сигнал с разъема SDX)
234 // BRDCHAR Buffer[128];
235 // BRD_CmpSC cmp_sc;
236 // cmp_sc.src = BRDcmps_CHAN0CLK;
237 //#if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
238 // IPC_getPrivateProfileString(iniSectionName, _BRDC("ComparatorThresholdCHAN0"), _BRDC("0.0"), Buffer, sizeof(Buffer), iniFilePath);
239 //#else
240 // GetPrivateProfileString(iniSectionName, _BRDC("ComparatorThresholdCHAN0"), _BRDC("0.0"), Buffer, sizeof(Buffer), iniFilePath);
241 //#endif
242 // cmp_sc.thr[0] = BRDC_atof(Buffer);//0.0;
243 //#if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
244 // IPC_getPrivateProfileString(iniSectionName, _BRDC("ComparatorThresholdSDX"), _BRDC("0.0"), Buffer, sizeof(Buffer), iniFilePath);
245 //#else
246 // GetPrivateProfileString(iniSectionName, _BRDC("ComparatorThresholdSDX"), _BRDC("0.0"), Buffer, sizeof(Buffer), iniFilePath);
247 //#endif
248 // cmp_sc.thr[1] = BRDC_atof(Buffer);//0.0;
249 // // задать источникик и пороги для компараторов
250 // status = BRD_ctrl(hADC, 0, BRDctrl_CMPSC_SET, &cmp_sc);
251 // if(BRD_errcmp(status, BRDerr_OK))
252 // BRDC_printf(_BRDC("BRDctrl_CMPSC_SET: comparator source = %d, thresholdCHAN0 = %.2f, thresholdSDX = %.2f\n"),
253 // cmp_sc.src, cmp_sc.thr[0], cmp_sc.thr[1]);
254 // else
255 // DisplayError(status, __FUNCTION__, _BRDC("BRDctrl_CMPSC_SET"));
256 // }
257  }
258  else
259  { // стартовая схема на субмодуле (используется большая структура)
260  BRD_AdcStartMode* start = (BRD_AdcStartMode*)start_struct;
261  // службы: ADC212X200M, ADC10X2G, ADC214X200M, ADC28X1G, ADC214X400M, ADC210X1G,
262  // FM814X125M, FM214X250M, FM412X500M, FM212X1G
263  BRDC_printf(_BRDC("BRDctrl_ADC_GETSTARTMODE: start source = %d\n"), start->src);
264  }
265  }
266  else
267  DisplayError(status, __FUNCTION__, _BRDC("BRDctrl_ADC_GETSTARTMODE"));
268 
269 // if(start->startSrc == BRDsts_CMP0 || start->startSrc == BRDsts_CMP1)
270  { // старт от компаратора 0 (сигнал канала 0) или от компаратора 1 (сигнал с разъема SDX)
271  BRDCHAR buf0[128];
272  BRDCHAR buf1[128];
273  BRD_CmpSC cmp_sc;
274  cmp_sc.src = BRDcmps_CHAN0CLK;
275 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
276  IPC_getPrivateProfileString(iniSectionName, _BRDC("ComparatorThresholdCHAN0"), _BRDC(""), buf0, sizeof(buf0), iniFilePath);
277  IPC_getPrivateProfileString(iniSectionName, _BRDC("ComparatorThresholdSDX"), _BRDC(""), buf1, sizeof(buf1), iniFilePath);
278 #else
279  GetPrivateProfileString(iniSectionName, _BRDC("ComparatorThresholdCHAN0"), _BRDC(""), buf0, sizeof(buf0), iniFilePath);
280  GetPrivateProfileString(iniSectionName, _BRDC("ComparatorThresholdSDX"), _BRDC(""), buf1, sizeof(buf1), iniFilePath);
281 #endif
282  if(BRDC_strlen(buf0) || BRDC_strlen(buf1))
283  {
284  if(BRDC_strlen(buf0))
285  cmp_sc.thr[0] = BRDC_atof(buf0);//0.0;
286  else
287  cmp_sc.thr[0] = 0.0;
288  if(BRDC_strlen(buf1))
289  cmp_sc.thr[1] = BRDC_atof(buf1);//0.0;
290  else
291  cmp_sc.thr[1] = 0.0;
292  // задать источникик и пороги для компараторов
293  status = BRD_ctrl(hADC, 0, BRDctrl_CMPSC_SET, &cmp_sc);
294  if(BRD_errcmp(status, BRDerr_OK))
295  BRDC_printf(_BRDC("BRDctrl_CMPSC_SET: comparator source = %d, thresholdCHAN0 = %.2f, thresholdSDX = %.2f\n"),
296  cmp_sc.src, cmp_sc.thr[0], cmp_sc.thr[1]);
297  else
298  DisplayError(status, __FUNCTION__, _BRDC("BRDctrl_CMPSC_SET"));
299  }
300  }
301 
302  // получить маску включенных каналов
303  ULONG chan_mask = 0;
304  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_GETCHANMASK, &chan_mask);
305  //status = BRD_ctrl(hADC, 0, BRDctrl_ADC_SETCHANMASK, &chan_mask);
306  if(BRD_errcmp(status, BRDerr_OK))
307  BRDC_printf(_BRDC("BRDctrl_ADC_GETCHANMASK: chan_mask = %0X\n"), chan_mask);
308  else
309  DisplayError(status, __FUNCTION__, _BRDC("BRDctrl_ADC_GETCHANMASK"));
310  U32 i = 0;
311  S32 numChan = 0;
312  //numChan = (chan_mask & 0x1) + ((chan_mask >> 1) & 0x1) + ((chan_mask >> 2) & 0x1) + ((chan_mask >> 3) & 0x1);
313  for(i = 0; i < MAX_CHAN; i++)
314  numChan += (chan_mask >> i) & 0x1;
315 
316  // получить формат данных
317  ULONG format = 0;
318  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_GETFORMAT, &format);
319  if(BRD_errcmp(status, BRDerr_OK))
320  BRDC_printf(_BRDC("BRDctrl_ADC_GETFORMAT: format = %0X\n"), format);
321  else
322  DisplayError(status, __FUNCTION__, _BRDC("BRDctrl_ADC_GETFORMAT"));
323 
324  BRD_ValChan value_chan;
325  for(i = 0; i < adc_cfg.NumChans; i++)
326 // for(i = 0; i < numChan; i++)
327  {
328  value_chan.chan = i;
329  BRDC_printf(_BRDC("Channel %d:\n"), value_chan.chan);
330 
331  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_GETINPRANGE, &value_chan);
332  if(BRD_errcmp(status, BRDerr_OK))
333 // printf("BRDctrl_ADC_GETINPRANGE: range of channel %d = %f\n", value_chan.chan, value_chan.value);
334  BRDC_printf(_BRDC("Range = %f\n"), value_chan.value);
335  else
336  DisplayError(status, __FUNCTION__, _BRDC("BRDctrl_ADC_GETINPRANGE"));
337 
338  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_GETBIAS, &value_chan);
339  if(BRD_errcmp(status, BRDerr_OK))
340 // printf("BRDctrl_ADC_GETBIAS: bias of channel %d = %f\n", value_chan.chan, value_chan.value);
341  BRDC_printf(_BRDC("Bias = %f\n"), value_chan.value);
342  else
343  DisplayError(status, __FUNCTION__, _BRDC("BRDctrl_ADC_GETBIAS"));
344 
345  if(BRDC_strstr(srvName, _BRDC("ADC212X200M"))
346  || BRDC_strstr(srvName, _BRDC("ADC214X200M"))
347  || BRDC_strstr(srvName, _BRDC("ADC214X400M"))
348  || BRDC_strstr(srvName, _BRDC("ADC10X2G"))
349  || BRDC_strstr(srvName, _BRDC("ADC216X100M"))
350  || BRDC_strstr(srvName, _BRDC("FM814X125M")))
351  {
352  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_GETINPRESIST, &value_chan);
353  if(BRD_errcmp(status, BRDerr_OK))
354  {
355  if(value_chan.value)
356  BRDC_printf(_BRDC("Input resist is 50 Om\n"));
357  else
358  {
359  if(BRDC_strstr(srvName, _BRDC("ADC216X100M")))
360  BRDC_printf(_BRDC("Input resist is 1 kOm\n"));
361  else
362  BRDC_printf(_BRDC("Input resist is 1 MOm\n"));
363  }
364  }
365  else
366  DisplayError(status, __FUNCTION__, _BRDC("BRDctrl_ADC_GETINPRESIST"));
367  }
368  if(BRDC_strstr(srvName, _BRDC("ADC28X1G"))
369  || BRDC_strstr(srvName, _BRDC("ADC212X200M"))
370  || BRDC_strstr(srvName, _BRDC("ADC214X200M"))
371  || BRDC_strstr(srvName, _BRDC("ADC214X400M"))
372  || BRDC_strstr(srvName, _BRDC("ADC10X2G"))
373  || BRDC_strstr(srvName, _BRDC("ADC216X100M"))
374  || BRDC_strstr(srvName, _BRDC("FM814X125M")))
375  {
376  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_GETDCCOUPLING, &value_chan);
377  if(BRD_errcmp(status, BRDerr_OK))
378  {
379  if(value_chan.value)
380  BRDC_printf(_BRDC("Input is OPENED\n"));
381  else
382  BRDC_printf(_BRDC("Input is CLOSED\n"));
383  }
384  else
385  DisplayError(status, __FUNCTION__, _BRDC("BRDctrl_ADC_GETDCCOUPLING"));
386  }
387  }
388 
389  BRDCHAR Buffer[128];
390 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
391  IPC_getPrivateProfileString(iniSectionName, _BRDC("IsPreTriggerMode"), _BRDC("0"), Buffer, sizeof(Buffer), iniFilePath);
392 #else
393  GetPrivateProfileString(iniSectionName, _BRDC("IsPreTriggerMode"), _BRDC("0"), Buffer, sizeof(Buffer), iniFilePath);
394 #endif
395  g_PretrigMode = BRDC_atoi(Buffer);
396 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
397  IPC_getPrivateProfileString(iniSectionName, _BRDC("MemPostSamples"), _BRDC("16384"), Buffer, sizeof(Buffer), iniFilePath);
398 #else
399  GetPrivateProfileString(iniSectionName, _BRDC("MemPostSamples"), _BRDC("16384"), Buffer, sizeof(Buffer), iniFilePath);
400 #endif
401  g_nPostTrigSamples = BRDC_atoi64(Buffer);
402 
403  BRD_PretrigMode premode;
404  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_GETPRETRIGMODE, &premode);
405  if(!BRD_errcmp(status, BRDerr_OK))
406  //BRDC_printf(_BRDC("Bias = %f\n"), premode.enable);
407  //else
408  DisplayError(status, __FUNCTION__, _BRDC("BRDctrl_ADC_GETPRETRIGMODE"));
409 
410  if(premode.enable)
411  {
412  BRDC_printf(_BRDC("Pre-trigger is enabled. "));
413  if(premode.assur)
414  BRDC_printf(_BRDC("Pre-trigger is assurance. "));
415  if(premode.external)
416  {
417  BRDC_printf(_BRDC("Post-trigger data size = %lld \n"), g_nPostTrigSamples);
418  }
419  else
420  {
421  BRDC_printf(_BRDC("Pre-trigger data size = %d \n"), premode.size);
422  }
423  }
424  //GetPrivateProfileString("Option", "PreTriggerSamples", "16", Buffer, sizeof(Buffer), iniFilePath);
425  //g_nPreTrigSamples = _atoi64(Buffer);
426 
427  //BRD_PretrigMode pretrigger;
428  //pretrigger.enable = 0;
429  //pretrigger.assur = 0;
430  //pretrigger.external = 0;
431  //if(g_PretrigMode)
432  //{
433  // pretrigger.enable = 1;
434  // pretrigger.assur = (g_PretrigMode == 2) ? 1 : 0;
435  //}
436  //ULONG sample_size = format ? sizeof(char) : sizeof(short);
437  //pretrigger.size = ULONG((g_nPreTrigSamples * numChan * sample_size) / sizeof(ULONG));
438  //status = BRD_ctrl(hADC, 0, BRDctrl_ADC_SETPRETRIGMODE, &pretrigger);
439 
440 // printf("Press any key to continue...\n");
441 // _getch();
442 
443  CheckClock(hADC, srvName);
444 
445  if(!BRDC_stricmp(srvName, _BRDC("ADC214X200M")))
446  {
447  BRDC_printf(_BRDC("Sleeping 600 ms.\n"));
448 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
449  IPC_delay(200);
450  IPC_delay(200);
451  IPC_delay(200);
452 #else
453  Sleep(200);
454  Sleep(200);
455  Sleep(200);
456 #endif
457  }
458  BRDC_printf(_BRDC("ADC DRQ flag = %0X\n"), g_AdcDrqFlag);
459  BRDC_printf(_BRDC("SDRAM DRQ flag = %0X\n"), g_MemDrqFlag);
460 
461 // отладочные команды
462  if(g_IoDelay != 128)
463  {
464  ULONG stabil = 2; // сброс задержки
465  BRD_AdcSpec spec;
466  spec.command = ADCcmd_ADJUST;
467  spec.arg = &stabil;
468  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_SETSPECIFIC, &spec);
469  BRDC_printf(_BRDC("IoDelay reset!\n"));
470  if(g_IoDelay)
471  {
472  stabil = (g_IoDelay >= 0) ? 1 : 0;
473  spec.arg = &stabil;
474  int num = abs(g_IoDelay);
475  for(int i = 0; i < num; i++)
476  {
477  BRD_ctrl(hADC, 0, BRDctrl_ADC_SETSPECIFIC, &spec);
478  }
479  BRDC_printf(_BRDC("IoDelay = %d\n"), g_IoDelay);
480  }
481  }
482 
483 
484 
485 
486 
487  if(g_fileMap || g_DirWriteFile == -1)
488  {
489  if(!g_hPostfixFileMap)
490  {
491  BRDCHAR namePostfixMap[64] = _BRDC("data_postfix");
492 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
493  g_hPostfixFileMap = IPC_createSharedMemory(namePostfixMap, 4096);
494  g_pPostfix = (char*)IPC_mapSharedMemory(g_hPostfixFileMap);
495 #else
496  g_hPostfixFileMap = CreateFileMapping(INVALID_HANDLE_VALUE,
497  NULL, PAGE_READWRITE,
498  0, 4096,
499  namePostfixMap);
500  g_pPostfix = (char*)MapViewOfFile(g_hPostfixFileMap, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
501 #endif
502  ULONG sample_size = format ? format : sizeof(short);
503  g_bBufSize = (g_samplesOfChannel * numChan) * sample_size; // получить размер собираемых данных в байтах
504  }
505  if(g_DirWriteFile == -1)
506  MappingIsviParams(hADC, g_FileBufSize);
507  else
508  MappingIsviParams(hADC, g_bBufSize);
509  }
510 
511  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_PREPARESTART, NULL );
512 
513 
514  return numChan;
515 }
516 
517 void MappingIsviParams(BRD_Handle hADC, unsigned long long nNumberOfBytes)
518 {
519  char str_buf[512];
520 
521  sprintf(g_pPostfix, "\r\nDEVICE_NAME_________ " );
522 #ifdef _WIN64
523  char srvName[32];
524  wcstombs(srvName, g_AdcSrvName, 32);
525  lstrcatA(g_pPostfix, srvName);
526 #else
527  lstrcatA(g_pPostfix, g_AdcSrvName);
528 #endif
529 
530  BRD_AdcCfg adc_cfg;
531  BRD_ctrl(hADC, 0, BRDctrl_ADC_GETCFG, &adc_cfg);
532  //BRD_ctrl(hADC, 0, BRDctrl_ADC_GETRATE, &g_samplRate);
533  ULONG chanMask;
534  BRD_ctrl(hADC, 0, BRDctrl_ADC_GETCHANMASK, &chanMask);
535  ULONG format = 0;
536  BRD_ctrl(hADC, 0, BRDctrl_ADC_GETFORMAT, &format);
537 
538  ULONG is_complex = 0;
539 
540  int num_chan = 0;
541  int chans[MAX_CHAN];
542  double gains[MAX_CHAN];
543  double volt_offset[MAX_CHAN];
544  ULONG mask = 1;
545  BRD_ValChan val_chan;
546  for(ULONG iChan = 0; iChan < adc_cfg.NumChans; iChan++)
547  {
548  if(chanMask & mask)
549  chans[num_chan++] = iChan;
550  val_chan.chan = iChan;
551  BRD_ctrl(hADC, 0, BRDctrl_ADC_GETGAIN, &val_chan);
552  if(adc_cfg.ChanType == 1)
553  val_chan.value = pow(10., val_chan.value/20); // dB -> разы
554  gains[iChan] = val_chan.value;
555  volt_offset[iChan] = 0.0;
556  mask <<= 1;
557  }
558  sprintf(str_buf, "\r\nNUMBER_OF_CHANNELS__ %d", num_chan);
559  lstrcatA(g_pPostfix, str_buf);
560 
561  sprintf(str_buf, "\r\nNUMBERS_OF_CHANNELS_ ");
562  lstrcatA(g_pPostfix, str_buf);
563  str_buf[0] = 0;
564  for(int iChan = 0; iChan < num_chan; iChan++)
565  {
566  char buf[16];
567  sprintf(buf, "%d,", chans[iChan]);
568  lstrcatA(str_buf, buf);
569  }
570  lstrcatA(g_pPostfix, str_buf);
571 
572  ULONG sample_size = format ? format : sizeof(short);
573  ULONG samples = ULONG(nNumberOfBytes / sample_size / num_chan);
574  if(g_Cycle > 1)
575  samples *= g_Cycle;
576  sprintf(str_buf, "\r\nNUMBER_OF_SAMPLES___ %d", samples );
577  lstrcatA(g_pPostfix, str_buf);
578 
579  sprintf(str_buf, "\r\nSAMPLING_RATE_______ %f", g_samplRate );
580  lstrcatA(g_pPostfix, str_buf);
581 
582  sprintf(str_buf, "\r\nBYTES_PER_SAMPLES___ %d", sample_size);
583  lstrcatA(g_pPostfix, str_buf);
584 
585  lstrcatA(g_pPostfix, "\r\nSAMPLES_PER_BYTES___ 1");
586 
587  if(is_complex)
588  sprintf(str_buf, "\r\nIS_COMPLEX_SIGNAL?__ YES");
589  else
590  sprintf(str_buf, "\r\nIS_COMPLEX_SIGNAL?__ NO");
591  lstrcatA(g_pPostfix, str_buf);
592 
593  //double fc[MAX_CHAN];
594  sprintf(str_buf, "\r\nSHIFT_FREQUENCY_____ ");
595  lstrcatA(g_pPostfix, str_buf);
596  str_buf[0] = 0;
597  int num_fc = num_chan;
598  for(int iChan = 0; iChan < num_fc; iChan++)
599  {
600  //char buf[16];
601  //fc[iChan] = 0.0;
602  //sprintf(buf, "%.2f,", fc[iChan]);
603  //lstrcat(str_buf, buf);
604  lstrcatA(str_buf, "0.0,");
605  }
606  lstrcatA(g_pPostfix, str_buf);
607 
608  sprintf(str_buf, "\r\nGAINS_______________ ");
609  lstrcatA(g_pPostfix, str_buf);
610  str_buf[0] = 0;
611  for(int iChan = 0; iChan < num_chan; iChan++)
612  {
613  char buf[16];
614  sprintf(buf,"%f,", gains[chans[iChan]]);
615  lstrcatA(str_buf, buf);
616  }
617  lstrcatA(g_pPostfix, str_buf);
618 
619  sprintf(str_buf, "\r\nVOLTAGE_OFFSETS_____ ");
620  lstrcatA(g_pPostfix, str_buf);
621  str_buf[0] = 0;
622  for(int iChan = 0; iChan < num_chan; iChan++)
623  {
624  char buf[16];
625  sprintf(buf,"%f,", volt_offset[iChan]);
626  lstrcatA(str_buf, buf);
627  }
628  lstrcatA(g_pPostfix, str_buf);
629 
630  sprintf(str_buf, "\r\nVOLTAGE_RANGE_______ %f", adc_cfg.InpRange / 1000.);
631  lstrcatA(g_pPostfix, str_buf);
632 
633 // int BitsPerSample = !format ? adc_cfg.Bits : 8;
634 // if(is_complex)
635 // BitsPerSample = 16;
636  int BitsPerSample = (format == 1) ? 8 : adc_cfg.Bits;
637  if(BRDC_strstr(g_AdcSrvName, _BRDC("ADC1624X192")) || BRDC_strstr(g_AdcSrvName, _BRDC("ADC818X800")))
638  if(format == 0 || format == 2)
639  BitsPerSample = 16;
640  sprintf(str_buf, "\r\nBIT_RANGE___________ %d", BitsPerSample);
641  lstrcatA(g_pPostfix, str_buf);
642  lstrcatA(g_pPostfix, "\r\n");
643 
644  //int len = lstrlenA(g_pPostfix);
645 }
646 
647 // выполнить сбор данных в FIFO с программным методом передачи в ПК
648 S32 DaqIntoFifo(BRD_Handle hADC, PVOID pSig, ULONG bBufSize, int DspMode)
649 {
650  S32 status;
651  ULONG Status = 0;
652  ULONG Enable = 1;
653 
654  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_FIFORESET, NULL); // сборс FIFO АЦП
655 // if(DspMode)
656 // status = BRD_ctrl(hADC, 0, BRDctrl_DSPNODE_FIFORESET, NULL); // сброс FIFO ПЛИС ЦОС
657  if(g_MemAsFifo)
658  {
659  status = BRD_ctrl(hADC, 0, BRDctrl_SDRAM_FIFORESET, NULL); // сборс FIFO SDRAM
660  status = BRD_ctrl(hADC, 0, BRDctrl_SDRAM_ENABLE, &Enable); // разрешение записи в SDRAM
661  }
662  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_ENABLE, &Enable); // разрешение работы АЦП
663 
664  // дожидаемся заполнения FIFO
665  do {
666 // if(DspMode)
667 // status = BRD_ctrl(hADC, 0, BRDctrl_DSPNODE_FIFOSTATUS, &Status);
668 // else
669  if(g_MemAsFifo)
670  status = BRD_ctrl(hADC, 0, BRDctrl_SDRAM_FIFOSTATUS, &Status);
671  else
672  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_FIFOSTATUS, &Status);
673  } while(Status & 0x40);
674 
675  Enable = 0;
676  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_ENABLE, &Enable); // запрет работы АЦП
677 
678  if(g_MemAsFifo)
679  status = BRD_ctrl(hADC, 0, BRDctrl_SDRAM_ENABLE, &Enable); // запрет записи в SDRAM
680 
681  BRD_DataBuf data_buf;
682  data_buf.pData = pSig;
683  data_buf.size = bBufSize;
684 // if(DspMode)
685 // status = BRD_ctrl(hADC, 0, BRDctrl_DSPNODE_GETDATA, &data_buf);
686 // else
687  if(g_MemAsFifo)
688  status = BRD_ctrl(hADC, 0, BRDctrl_SDRAM_GETDATA, &data_buf);
689  else
690  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_GETDATA, &data_buf);
691 
692  return status;
693 }
694 
695 // выполнить сбор данных в FIFO с ПДП-методом передачи в ПК
696 //S32 DaqIntoFifoDMA(BRD_Handle hADC, int idx, ULONG bBufSize, int DspMode)
697 S32 DaqIntoFifoDMA(BRD_Handle hADC)
698 {
699  //if(DspMode)
700  // printf("DAQ into DSP FIFO\n");
701  //else
702  // printf("DAQ into ADC FIFO\n");
703  S32 status;
704  //ULONG Status = 0;
705  ULONG Enable = 1;
706 
707  // установить источник для работы стрима
708  ULONG tetrad;
709 // if(DspMode)
710 // status = BRD_ctrl(hADC, 0, BRDctrl_DSPNODE_GETSRCSTREAM, &tetrad); // стрим будет работать с ПЛИС ЦОС
711 // else
712  if(g_MemAsFifo)
713  status = BRD_ctrl(hADC, 0, BRDctrl_SDRAM_GETSRCSTREAM, &tetrad); // стрим будет работать с SDRAM
714  else
715  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_GETSRCSTREAM, &tetrad); // стрим будет работать с АЦП
716  status = BRD_ctrl(hADC, 0, BRDctrl_STREAM_SETSRC, &tetrad);
717 
718  // устанавливать флаг для формирования запроса ПДП надо после установки источника (тетрады) для работы стрима
719 // ULONG flag = BRDstrm_DRQ_ALMOST; // FIFO почти пустое
720 // ULONG flag = BRDstrm_DRQ_READY;
721 // ULONG flag = BRDstrm_DRQ_HALF; // рекомендуется флаг - FIFO наполовину заполнено
722  ULONG flag = g_AdcDrqFlag;
723  if(g_MemAsFifo)
724  flag = g_MemDrqFlag;
725  status = BRD_ctrl(hADC, 0, BRDctrl_STREAM_SETDRQ, &flag);
726  if(!BRD_errcmp(status, BRDerr_OK))
727  DisplayError(status, __FUNCTION__, _BRDC("BRDctrl_STREAM_SETDRQ"));
728 
729  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_FIFORESET, NULL); // сброс FIFO АЦП
730 // if(DspMode)
731 // status = BRD_ctrl(hADC, 0, BRDctrl_DSPNODE_FIFORESET, NULL); // сброс FIFO ПЛИС ЦОС
732  if(g_MemAsFifo)
733  {
734  status = BRD_ctrl(hADC, 0, BRDctrl_SDRAM_FIFORESET, NULL); // сброс FIFO SDRAM
735  status = BRD_ctrl(hADC, 0, BRDctrl_SDRAM_ENABLE, &Enable); // разрешение записи в SDRAM
736  }
737  status = BRD_ctrl(hADC, 0, BRDctrl_STREAM_RESETFIFO, NULL);
738 
739  BRDctrl_StreamCBufStart start_pars;
740  start_pars.isCycle = 0; // без зацикливания
741  status = BRD_ctrl(hADC, 0, BRDctrl_STREAM_CBUF_START, &start_pars); // старт ПДП
742 
743 #ifdef _WIN32
744  // определение скорости сбора данных
745  LARGE_INTEGER Frequency, StartPerformCount, StopPerformCount;
746  int bHighRes = QueryPerformanceFrequency (&Frequency);
747  QueryPerformanceCounter (&StartPerformCount);
748 #endif
749  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_ENABLE, &Enable); // разрешение работы АЦП
750 
751  ULONG msTimeout = 20000; // ждать окончания передачи данных до 20 сек.
752  status = BRD_ctrl(hADC, 0, BRDctrl_STREAM_CBUF_WAITBUF, &msTimeout);
753 #ifdef _WIN32
754  QueryPerformanceCounter (&StopPerformCount);
755 #endif
756  if(BRD_errcmp(status, BRDerr_WAIT_TIMEOUT))
757  { // если вышли по тайм-ауту, то остановимся
758  status = BRD_ctrl(hADC, 0, BRDctrl_STREAM_CBUF_STOP, NULL);
759  DisplayError(status, __FUNCTION__, _BRDC("TIME-OUT"));
760  }
761 /*
762  ULONG msTimeout = 0; // только проверка (без ожидания) - чтобы срабатывал Ctrl-Break
763  int i = 0;
764  for(i = 0; i < 200; i++)
765  {
766  status = BRD_ctrl(hADC, 0, BRDctrl_STREAM_CBUF_WAITBUF, &msTimeout);
767  if(BRD_errcmp(status, BRDerr_OK))
768  break;
769 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
770  IPC_delay(100);
771 #else
772  Sleep(100);
773 #endif
774  }
775  if(i>=200)
776  { // если вышли по тайм-ауту, то остановимся
777  status = BRD_ctrl(hADC, 0, BRDctrl_STREAM_CBUF_STOP, NULL);
778  DisplayError(status, __FUNCTION__, _BRDC("TIME-OUT"));
779  }
780  QueryPerformanceCounter (&StopPerformCount);
781 */
782  Enable = 0;
783  status = BRD_ctrl(hADC, 0, BRDctrl_ADC_ENABLE, &Enable); // запрет работы АЦП
784 
785  if(g_MemAsFifo)
786  status = BRD_ctrl(hADC, 0, BRDctrl_SDRAM_ENABLE, &Enable); // запрет записи в SDRAM
787 
788 #ifdef _WIN32
789  double msTime = (double)(StopPerformCount.QuadPart - StartPerformCount.QuadPart) / (double)Frequency.QuadPart * 1.E3;
790  if(g_transRate)
791  printf("DAQ & Transfer by bus rate is %.2f Mbytes/sec\r", ((double)g_bBufSize / msTime)/1000.);
792 #endif
793 
794  return status;
795 }
796 
797 // размещение буфера для получения данных с АЦП через Стрим
798 // hADC - дескриптор службы АЦП (IN)
799 // pSig - указатель на массив указателей (IN), каждый элемент массива является указателем на блок (OUT)
800 // pbytesBufSize - общий размер данных (всех блоков составного буфера), которые должны быть выделены (IN/OUT - может меняться внутри функции)
801 // bufType - тип памяти для данных (IN):
802 // 0 - пользовательская память выделяется в драйвере (точнее, в DLL базового модуля)
803 // 1 - системная память выделяется драйвере 0-го кольца
804 // 2 - пользовательская память выделяется в приложении
805 // pBlkNum - число блоков составного буфера (OUT)
806 S32 AllocDaqBuf(BRD_Handle hADC, PVOID* &pSig, unsigned long long* pbytesBufSize, ULONG bufType, ULONG* pBlkNum)
807 {
808  S32 status;
809 
810  unsigned long long bBufSize = *pbytesBufSize;
811  ULONG bBlkSize;
812  ULONG blkNum = 1;
813  // определяем число блоков составного буфера
814 // if(bBufSize > 2147483648) // максимальный размер блока = 2 Гбайта
815  if(bBufSize > 1073741824) // максимальный размер блока = 1 Гбайт
816  {
817  do
818  {
819  blkNum <<= 1;
820  bBufSize >>= 1;
821  }while(bBufSize > 1073741824);
822  }
823  bBlkSize = (ULONG)bBufSize;
824  void** pBuffer = NULL;
825  if(2 == bufType)
826  {
827  //pBuffer = malloc(*pbytesBufSize);
828  pBuffer = new PVOID[blkNum];
829 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
830  g_hBufFileMap = new IPC_handle[blkNum];
831 #else
832  g_hBufFileMap = new HANDLE[blkNum];
833 #endif
834  for(ULONG i = 0; i < blkNum; i++)
835  {
836  if(g_fileMap)
837  {
838  BRDCHAR nameBufMap[64];
839  BRDC_sprintf(nameBufMap, _BRDC("data_blk%d"), i);
840 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
841  g_hBufFileMap[i] = IPC_createSharedMemory(nameBufMap, bBlkSize);
842  pBuffer[i] = IPC_mapSharedMemory(g_hBufFileMap[i]);
843 #else
844  g_hBufFileMap[i] = CreateFileMapping(INVALID_HANDLE_VALUE,
845  NULL, PAGE_READWRITE,
846  0, bBlkSize,
847  nameBufMap);
848  pBuffer[i] = MapViewOfFile(g_hBufFileMap[i], FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
849 #endif
850 
851  }
852 #ifdef _WIN32
853  else
854  {
855  pBuffer[i] = VirtualAlloc(NULL, bBlkSize, MEM_COMMIT, PAGE_READWRITE);
856  if(!pBuffer[i])
857  {
858  BRDC_printf(_BRDC("VirtualAlloc() by allocating buffer %d is error!!!\n"), i);
859  return -1; // error
860  }
861  }
862 #endif
863  }
864  if(g_fileMap)
865  {
866  BRDCHAR nameFlagMap[64] = _BRDC("data_flg");
867  //BRDC_sprintf(nameFlagMap, _BRDC("data_flg"), i);
868 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
869  g_hFlgFileMap = IPC_createSharedMemory(nameFlagMap, 3* sizeof(ULONG));
870  g_pFlags = (ULONG*)IPC_mapSharedMemory(g_hFlgFileMap);
871 #else
872  g_hFlgFileMap = CreateFileMapping(INVALID_HANDLE_VALUE,
873  NULL, PAGE_READWRITE,
874  0, 3* sizeof(ULONG),
875  nameFlagMap);
876  g_pFlags = (ULONG*)MapViewOfFile(g_hFlgFileMap, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
877 #endif
878  }
879  }
880  g_buf_dscr.dir = BRDstrm_DIR_IN;
881  g_buf_dscr.isCont = bufType; // 0 - буфер размещается в пользовательской памяти ПК, 1 - в системной
882  g_buf_dscr.blkNum = blkNum;
883  g_buf_dscr.blkSize = bBlkSize;//*pbytesBufSize;
884  g_buf_dscr.ppBlk = new PVOID[g_buf_dscr.blkNum];
885  if(g_buf_dscr.isCont == 2)
886  {
887  for(ULONG i = 0; i < blkNum; i++)
888  g_buf_dscr.ppBlk[i] = pBuffer[i];
889  delete[] pBuffer;
890  }
891  status = BRD_ctrl(hADC, 0, BRDctrl_STREAM_CBUF_ALLOC, &g_buf_dscr);
892  if(!BRD_errcmp(status, BRDerr_OK) && !BRD_errcmp(status, BRDerr_PARAMETER_CHANGED))
893  DisplayError(status, __FUNCTION__, _BRDC("BRDctrl_STREAM_CBUF_ALLOC"));
894  if(BRD_errcmp(status, BRDerr_PARAMETER_CHANGED))
895  { // может быть выделено меньшее количество памяти
896  BRDC_printf(_BRDC("Warning!!! BRDctrl_STREAM_CBUF_ALLOC: BRDerr_PARAMETER_CHANGED\n"));
897  status = BRDerr_OK;
898  }
899  //*pSig = g_buf_dscr.ppBlk[0];
900  pSig = new PVOID[blkNum];
901  for(ULONG i = 0; i < blkNum; i++)
902  {
903  pSig[i] = g_buf_dscr.ppBlk[i];
904  }
905  *pbytesBufSize = (unsigned long long)g_buf_dscr.blkSize * blkNum;
906  *pBlkNum = blkNum;
907  BRDC_printf(_BRDC("Allocated memory for Stream:: Number of blocks = %d, Block size = %d kBytes\n"),
908  blkNum, g_buf_dscr.blkSize/1024);
909  return status;
910 }
911 
912 // освобождение буфера для получения данных с АЦП через Стрим
913 S32 FreeDaqBuf(BRD_Handle hADC, ULONG blkNum)
914 {
915  S32 status;
916  status = BRD_ctrl(hADC, 0, BRDctrl_STREAM_CBUF_FREE, NULL);
917  if(!BRD_errcmp(status, BRDerr_OK))
918  DisplayError(status, __FUNCTION__, _BRDC("BRDctrl_STREAM_CBUF_FREE"));
919  if(g_buf_dscr.isCont == 2)
920  {
921  for(ULONG i = 0; i < blkNum; i++)
922  {
923  if(g_fileMap)
924  {
925 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
926  IPC_unmapSharedMemory(g_hBufFileMap[i]);
927  IPC_deleteSharedMemory(g_hBufFileMap[i]);
928 #else
929  UnmapViewOfFile(g_buf_dscr.ppBlk[i]);
930  CloseHandle(g_hBufFileMap[i]);
931 #endif
932  }
933 #ifdef _WIN32
934  else
935  VirtualFree(g_buf_dscr.ppBlk[i], 0, MEM_RELEASE);
936 #endif
937  }
938  if(g_fileMap)
939  {
940 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
941  IPC_unmapSharedMemory(g_hFlgFileMap);
942  IPC_deleteSharedMemory(g_hFlgFileMap);
943 #else
944  UnmapViewOfFile(g_pFlags);
945  CloseHandle(g_hFlgFileMap);
946 #endif
947  }
948  }
949  delete[] g_buf_dscr.ppBlk;
950  //delete pSig;
951  return status;
952 }
953 
954 // размещение 1-блокового буфера для получения данных с АЦП через Стрим
955 //S32 AllocDaqBuf(BRD_Handle hADC, PVOID* pSig, unsigned long long* pbytesBufSize, ULONG bufType)
956 //{
957 // S32 status;
958 //
959 // void* pBuffer = NULL;
960 // if(2 == bufType)
961 // {
962 // pBuffer = malloc(*pbytesBufSize);
963 //// pBuffer = VirtualAlloc(NULL, bBufSize, MEM_COMMIT, PAGE_READWRITE);
964 // if(!pBuffer)
965 // {
966 // BRDC_printf(_BRDC("VirtualAlloc() is error!!!\n"));
967 // return -1; // error
968 // }
969 // }
970 // g_buf_dscr.dir = BRDstrm_DIR_IN;
971 // g_buf_dscr.isCont = bufType; // 0 - буфер размещается в пользовательской памяти ПК, 1 - в системной
972 // g_buf_dscr.blkNum = 1;
973 // g_buf_dscr.blkSize = *pbytesBufSize;
974 // g_buf_dscr.ppBlk = new PVOID[g_buf_dscr.blkNum];
975 // if(g_buf_dscr.isCont == 2)
976 // g_buf_dscr.ppBlk[0] = pBuffer;
977 // status = BRD_ctrl(hADC, 0, BRDctrl_STREAM_CBUF_ALLOC, &g_buf_dscr);
978 // if(!BRD_errcmp(status, BRDerr_OK) && !BRD_errcmp(status, BRDerr_PARAMETER_CHANGED))
979 // DisplayError(status, __FUNCTION__, _BRDC("BRDctrl_STREAM_CBUF_ALLOC"));
980 // if(BRD_errcmp(status, BRDerr_PARAMETER_CHANGED))
981 // {
982 // BRDC_printf(_BRDC("Warning!!! BRDctrl_STREAM_CBUF_ALLOC: BRDerr_PARAMETER_CHANGED\n"));
983 // status = BRDerr_OK;
984 // }
985 // *pSig = g_buf_dscr.ppBlk[0];
986 // *pbytesBufSize = g_buf_dscr.blkSize;
987 //// printf("BRDctrl_STREAM_CBUF_ALLOC:: %d kBytes, memory type = %d\n", (*pbytesBufSize)/1024, bufType);
988 // return status;
989 //}
990 
991 // освобождение 1-блокового буфера для получения данных с АЦП через Стрим
992 //S32 FreeDaqBuf(BRD_Handle hADC)
993 //{
994 // S32 status;
995 // status = BRD_ctrl(hADC, 0, BRDctrl_STREAM_CBUF_FREE, NULL);
996 // if(!BRD_errcmp(status, BRDerr_OK))
997 // DisplayError(status, __FUNCTION__, _BRDC("BRDctrl_STREAM_CBUF_FREE"));
998 // if(g_buf_dscr.isCont == 2)
999 // free(g_buf_dscr.ppBlk[0]);
1000 //// VirtualFree(g_buf_dscr.ppBlk[0], 0, MEM_RELEASE);
1001 // delete[] g_buf_dscr.ppBlk;
1002 // return status;
1003 //}
1004 
1005 void MapWrFlagSinc(int flg, int isNewParam)
1006 {
1007  g_pFlags[0] = flg;
1008  g_pFlags[1] = isNewParam;
1009  g_pFlags[2] = g_buf_dscr.blkSize;
1010 }
1011 
1012 int MapRdFlagSinc()
1013 {
1014  int flg = g_pFlags[0];
1015  return flg;
1016 }
1017 
1018 typedef struct _THREAD_PARAM {
1019  BRD_Handle handle;
1020  int idx;
1021 } THREAD_PARAM, *PTHREAD_PARAM;
1022 
1023 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
1024 thread_value __IPC_API DirWriteIntoFile(void* pParams);
1025 int SimpleProcWrDir(BRD_Handle hSrv, IPC_handle hfile, int idx, BRDctrl_StreamCBufAlloc* buf_dscr);
1026 int MultiBlkProcWrDir(BRD_Handle hSrv, IPC_handle hfile, int idx, BRDctrl_StreamCBufAlloc* buf_dscr);
1027 #else
1028 unsigned __stdcall DirWriteIntoFile(void* pParams);
1029 int SimpleProcWrDir(BRD_Handle hSrv, HANDLE hfile, int idx, BRDctrl_StreamCBufAlloc* buf_dscr);
1030 int MultiBlkProcWrDir(BRD_Handle hSrv, HANDLE hfile, int idx, BRDctrl_StreamCBufAlloc* buf_dscr);
1031 #endif
1032 
1033 void DspFunc(void* buf, ULONG size);
1034 
1035 int g_flbreak = 0;
1036 
1037 ULONG g_bufType;
1038 ULONG g_fileBufSize;
1039 ULONG g_fileBufNum;
1040 ULONG g_fileBlkNum;
1041 
1042 void DirectFile(ULONG bufType, ULONG FileBufSize, ULONG FileBufNum, ULONG FileBlkNum)
1043 {
1044  THREAD_PARAM thread_par;
1045 
1046 #ifdef _WIN32
1047  SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
1048  DWORD prior_class = GetPriorityClass(GetCurrentProcess());
1049  BRDC_printf(_BRDC("Process Priority = %d\n"), prior_class);
1050 #endif
1051 
1052  g_bufType = bufType;
1053  g_fileBufSize = FileBufSize;
1054  g_fileBufNum = FileBufNum;
1055  g_fileBlkNum = FileBlkNum;
1056 
1057  g_flbreak = 0;
1058  thread_par.handle = g_hSRV;
1059  thread_par.idx = 0;
1060 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
1061  IPC_handle hThread = IPC_createThread( _BRDC("DirWriteIntoFile"), &DirWriteIntoFile, &thread_par );
1062  IPC_waitThread(hThread, INFINITE );// Wait until threads terminates
1063  IPC_deleteThread(hThread);
1064 #else
1065  unsigned threadID;
1066  HANDLE hThread = (HANDLE)_beginthreadex( NULL, 0, &DirWriteIntoFile, &(thread_par), 0, &(threadID) );
1067  WaitForSingleObject(hThread, INFINITE ); // Wait until threads terminates
1068  CloseHandle(hThread);
1069 #endif
1070 }
1071 
1072 extern BRDCHAR g_dirFileName[];
1073 //extern ULONG g_flDirFileName;
1074 
1075 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
1076 thread_value __IPC_API DirWriteIntoFile(void* pParams)
1077 #else
1078 unsigned __stdcall DirWriteIntoFile(void* pParams)
1079 #endif
1080 {
1081  S32 status = BRDerr_OK;
1082  ULONG Status = 0;
1083 #ifdef _WIN32
1084  SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
1085  int prior = GetThreadPriority(GetCurrentThread());
1086  BRDC_printf(_BRDC("Thread Priority = %d\n"), prior);
1087 #endif
1088  PTHREAD_PARAM pThreadParam = (PTHREAD_PARAM)pParams;
1089  BRD_Handle hSrv = pThreadParam->handle;
1090  int idx = pThreadParam->idx;
1091 
1092  BRDCHAR fileName[MAX_PATH];
1093  if(idx)
1094  BRDC_sprintf(fileName, _BRDC("%s_%d.bin"), g_dirFileName, idx);
1095  else
1096  BRDC_strcpy(fileName, g_dirFileName);
1097 
1098 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
1099  IPC_handle hfile = IPC_openFileEx(fileName,
1100  IPC_CREATE_FILE | IPC_FILE_WRONLY,
1101  IPC_FILE_NOBUFFER);
1102  if(!hfile)
1103  {
1104  BRDC_printf(_BRDC("Create file error\n"));
1105  return (thread_value)status;
1106  }
1107 #else
1108  HANDLE hfile = CreateFile( fileName,
1109  GENERIC_WRITE,
1110 // FILE_SHARE_WRITE | FILE_SHARE_READ,
1111  0,
1112  NULL,
1113  CREATE_ALWAYS,
1114 // FILE_ATTRIBUTE_NORMAL,
1115  FILE_FLAG_NO_BUFFERING,// | FILE_FLAG_WRITE_THROUGH,
1116  NULL);
1117  if(hfile == INVALID_HANDLE_VALUE)
1118  {
1119  BRDC_printf(_BRDC("Create file error\n"));
1120  return status;
1121  }
1122 #endif
1123 
1124  BRDctrl_StreamCBufAlloc buf_dscr;
1125  buf_dscr.dir = BRDstrm_DIR_IN;
1126  buf_dscr.isCont = g_bufType; // 0/1 - буфер размещается в пользовательской/системной памяти ПК
1127  buf_dscr.blkNum = g_fileBlkNum;
1128  buf_dscr.blkSize = g_fileBufSize;
1129  buf_dscr.ppBlk = new PVOID[buf_dscr.blkNum];
1130  status = BRD_ctrl(hSrv, 0, BRDctrl_STREAM_CBUF_ALLOC, &buf_dscr);
1131  if(!BRD_errcmp(status, BRDerr_OK) && !BRD_errcmp(status, BRDerr_PARAMETER_CHANGED))
1132  {
1133  BRDC_printf(_BRDC("ERROR!!! BRDctrl_STREAM_CBUF_ALLOC\n"));
1134 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
1135  return (thread_value)status;
1136 #else
1137  return status;
1138 #endif
1139  }
1140  if(BRD_errcmp(status, BRDerr_PARAMETER_CHANGED))
1141  {
1142  BRDC_printf(_BRDC("Warning!!! BRDctrl_STREAM_CBUF_ALLOC: BRDerr_PARAMETER_CHANGED\n"));
1143  status = BRDerr_OK;
1144  }
1145  BRDC_printf(_BRDC("Block size = %d Mbytes, Block num = %d, Total blocks = %d\n"), buf_dscr.blkSize / 1024 / 1024, buf_dscr.blkNum, g_fileBufNum);
1146 
1147  // установить источник для работы стрима
1148  ULONG tetrad;
1149  if(g_MemAsFifo)
1150  status = BRD_ctrl(hSrv, 0, BRDctrl_SDRAM_GETSRCSTREAM, &tetrad); // стрим будет работать с SDRAM
1151  else
1152  status = BRD_ctrl(hSrv, 0, BRDctrl_ADC_GETSRCSTREAM, &tetrad); // стрим будет работать с АЦП
1153  status = BRD_ctrl(hSrv, 0, BRDctrl_STREAM_SETSRC, &tetrad);
1154 
1155  // устанавливать флаг для формирования запроса ПДП надо после установки источника (тетрады) для работы стрима
1156 // ULONG flag = BRDstrm_DRQ_ALMOST; // FIFO почти пустое
1157 // ULONG flag = BRDstrm_DRQ_READY;
1158 // ULONG flag = BRDstrm_DRQ_HALF; // рекомендуется флаг - FIFO наполовину заполнено
1159  ULONG flag = g_AdcDrqFlag;
1160  if(g_MemAsFifo)
1161  flag = g_MemDrqFlag;
1162  status = BRD_ctrl(hSrv, 0, BRDctrl_STREAM_SETDRQ, &flag);
1163 
1164  ULONG Enable = 1;
1165  status = BRD_ctrl(hSrv, 0, BRDctrl_ADC_FIFORESET, NULL); // сброс FIFO АЦП
1166  status = BRD_ctrl(hSrv, 0, BRDctrl_STREAM_RESETFIFO, NULL);
1167  if(g_MemAsFifo)
1168  {
1169  status = BRD_ctrl(hSrv, 0, BRDctrl_SDRAM_FIFORESET, NULL); // сборс FIFO SDRAM
1170  status = BRD_ctrl(hSrv, 0, BRDctrl_SDRAM_ENABLE, &Enable); // разрешение записи в SDRAM
1171  }
1172 
1173  BRDctrl_StreamCBufStart start_pars;
1174  start_pars.isCycle = 1; // с зацикливанием
1175  status = BRD_ctrl(hSrv, 0, BRDctrl_STREAM_CBUF_START, &start_pars); // старт ПДП
1176  status = BRD_ctrl(hSrv, 0, BRDctrl_ADC_ENABLE, &Enable); // разрешение работы АЦП
1177 
1178  int errCnt = 0;
1179  BRDC_printf(_BRDC("Data writing into file %s...\n"), fileName);
1180  if(g_fileBlkNum == 2)
1181  errCnt = SimpleProcWrDir(hSrv, hfile, idx, &buf_dscr);
1182  else
1183  errCnt = MultiBlkProcWrDir(hSrv, hfile, idx, &buf_dscr);
1184 
1185  Enable = 0;
1186  status = BRD_ctrl(hSrv, 0, BRDctrl_ADC_ENABLE, &Enable); // запрет работы АЦП
1187  if(g_MemAsFifo)
1188  status = BRD_ctrl(hSrv, 0, BRDctrl_SDRAM_ENABLE, &Enable); // запрет записи в SDRAM
1189 // printf(" \r");
1190  if(errCnt)
1191  BRDC_printf(_BRDC("ERROR (%s): buffers skiped %d\n"), fileName, errCnt);
1192  BRDC_printf(_BRDC("Total Buffer Counter (%s) = %d\n"), fileName, buf_dscr.pStub->totalCounter);
1193  status = BRD_ctrl(hSrv, 0, BRDctrl_ADC_FIFOSTATUS, &Status);
1194  if(Status & 0x80)
1195  BRDC_printf(_BRDC("ERROR (%s): ADC FIFO is overflow\n"), fileName);
1196  if(g_MemAsFifo)
1197  {
1198  status = BRD_ctrl(hSrv, 0, BRDctrl_SDRAM_FIFOSTATUS, &Status);
1199  if(Status & 0x80)
1200  BRDC_printf(_BRDC("ERROR (%s): SDRAM FIFO is overflow\n"), fileName);
1201  }
1202  status = BRD_ctrl(hSrv, 0, BRDctrl_STREAM_CBUF_FREE, &buf_dscr);
1203  delete[] buf_dscr.ppBlk;
1204 
1205 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
1206  IPC_closeFile(hfile);
1207  return (thread_value)status;
1208 #else
1209  CloseHandle(hfile);
1210  _endthreadex( 0 );
1211  return status;
1212 #endif
1213 }
1214 
1215 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
1216 int SimpleProcWrDir(BRD_Handle hSrv, IPC_handle hfile, int idx, BRDctrl_StreamCBufAlloc* buf_dscr)
1217 #else
1218 int SimpleProcWrDir(BRD_Handle hSrv, HANDLE hfile, int idx, BRDctrl_StreamCBufAlloc* buf_dscr)
1219 #endif
1220 {
1221  S32 status = BRDerr_OK;
1222  ULONG Status = 0;
1223  ULONG curbuf = 0;
1224  int cnt = 0;
1225  int errcnt = 0;
1226  ULONG msTimeout = 40000; // ждать окончания передачи данных до 40 сек.
1227  ULONG nNumberOfWriteBytes;
1228  for(ULONG i = 0; i < g_fileBufNum; i++)
1229  {
1230  status = BRD_ctrl(hSrv, 0, BRDctrl_STREAM_CBUF_WAITBLOCK, &msTimeout);
1231  if(BRD_errcmp(status, BRDerr_WAIT_TIMEOUT))
1232  { // если вышли по тайм-ауту, то остановимся
1233  status = BRD_ctrl(hSrv, 0, BRDctrl_ADC_FIFOSTATUS, &Status);
1234  BRDC_printf(_BRDC("ADC FIFO Status = 0x%04X\n"), Status);
1235  status = BRD_ctrl(hSrv, 0, BRDctrl_STREAM_CBUF_STOP, NULL);
1236  DisplayError(status, __FUNCTION__, _BRDC("TIME-OUT"));
1237  break;
1238  }
1239 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
1240  if(!idx && IPC_kbhit())
1241  {
1242  int ch = IPC_getch(); // получает клавишу
1243  if(0x1B == ch) // если Esc
1244  {
1245  g_flbreak = 1;
1246  break;
1247  }
1248  }
1249  IPC_writeFile(hfile, buf_dscr->ppBlk[curbuf], buf_dscr->blkSize);
1250 #else
1251  if(!idx && GetAsyncKeyState(VK_ESCAPE))
1252  {
1253  g_flbreak = 1;
1254  _getch();
1255  break;
1256  }
1257  if(g_flbreak)
1258  break;
1259  WriteFile(hfile, buf_dscr->ppBlk[curbuf], buf_dscr->blkSize, &nNumberOfWriteBytes, NULL);
1260 #endif
1261 // BOOL bResult = WriteFile(hfile, buf_dscr.ppBlk[curbuf], buf_dscr.blkSize, &nNumberOfWriteBytes, NULL);
1262  //PSHORT pSigBuf = PSHORT(buf_dscr.ppBlk[curbuf]);
1263  //LONG sum = 0;
1264  //for(ULONG j = 0; j < buf_dscr.blkSize/2; j++)
1265  // sum += pSigBuf[j];
1266  //LONG mo = sum / buf_dscr.blkSize;
1267  curbuf ^= 1;
1268  if(cnt+1 != (int)buf_dscr->pStub->totalCounter)
1269  errcnt++;
1270 // printf("ERROR: buffer %d skip\n", cnt);
1271  cnt = buf_dscr->pStub->totalCounter;
1272  if(i%4 == 0)
1273  BRDC_printf(_BRDC("Current buffer = %d\r"), cnt);
1274 // printf("Current buffer = %d, MO = %d\r", cnt, mo);
1275  }
1276  return errcnt;
1277 }
1278 
1279 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
1280 int MultiBlkProcWrDir(BRD_Handle hSrv, IPC_handle hfile, int idx, BRDctrl_StreamCBufAlloc* buf_dscr)
1281 #else
1282 int MultiBlkProcWrDir(BRD_Handle hSrv, HANDLE hfile, int idx, BRDctrl_StreamCBufAlloc* buf_dscr)
1283 #endif
1284 {
1285  S32 status = BRDerr_OK;
1286  ULONG Status = 0;
1287  ULONG total_cnt = 0;
1288  LONG delta_cnt = 0;
1289  LONG twice = 1;
1290  LONG cur_buf = 0;
1291  //LONG daq_buf = 0;
1292  ULONG write_cnt = 0;
1293  ULONG first_err = 0;
1294  int err_cnt = 0;
1295  int waitblk_cnt = 0;
1296  ULONG msTimeout = 40000; // ждать окончания передачи данных до 20 сек.
1297  ULONG nNumberOfWriteBytes;
1298  do
1299  {
1300  total_cnt = buf_dscr->pStub->totalCounter;
1301  delta_cnt = total_cnt - write_cnt;
1302  //printf("Delta = %d, total %d\n", delta_cnt, total_cnt);
1303  if(delta_cnt > (S32)buf_dscr->blkNum)
1304  {
1305  if(!err_cnt)
1306  first_err = write_cnt;
1307  err_cnt++;
1308  delta_cnt = 0;
1309  }
1310  if(delta_cnt <= 0 || !(delta_cnt % buf_dscr->blkNum))
1311  {
1312  //printf("Waiting...\n");
1313  waitblk_cnt++;
1314  status = BRD_ctrl(hSrv, 0, BRDctrl_STREAM_CBUF_WAITBLOCK, &msTimeout);
1315  if(BRD_errcmp(status, BRDerr_WAIT_TIMEOUT))
1316  { // если вышли по тайм-ауту, то остановимся
1317  status = BRD_ctrl(hSrv, 0, BRDctrl_ADC_FIFOSTATUS, &Status);
1318  BRDC_printf(_BRDC("ADC FIFO Status = 0x%04X\n"), Status);
1319  status = BRD_ctrl(hSrv, 0, BRDctrl_STREAM_CBUF_STOP, NULL);
1320  DisplayError(status, __FUNCTION__, _BRDC("TIME-OUT"));
1321  break;
1322  }
1323  if(twice)
1324  {
1325  status = BRD_ctrl(hSrv, 0, BRDctrl_STREAM_CBUF_WAITBLOCK, &msTimeout);
1326  if(BRD_errcmp(status, BRDerr_WAIT_TIMEOUT))
1327  { // если вышли по тайм-ауту, то остановимся
1328  status = BRD_ctrl(hSrv, 0, BRDctrl_ADC_FIFOSTATUS, &Status);
1329  BRDC_printf(_BRDC("ADC FIFO Status = 0x%04X\n"), Status);
1330  status = BRD_ctrl(hSrv, 0, BRDctrl_STREAM_CBUF_STOP, NULL);
1331  DisplayError(status, __FUNCTION__, _BRDC("TIME-OUT"));
1332  break;
1333  }
1334  }
1335  delta_cnt = 1;
1336  twice = 0;
1337  //total_cnt++;
1338  }
1339  else
1340  twice = 1;
1341 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
1342  if(!idx && IPC_kbhit())
1343  {
1344  int ch = IPC_getch(); // получает клавишу
1345  if(0x1B == ch) // если Esc
1346  {
1347  g_flbreak = 1;
1348  break;
1349  }
1350  }
1351 #else
1352  if(!idx && GetAsyncKeyState(VK_ESCAPE))
1353  {
1354  g_flbreak = 1;
1355  _getch();
1356  break;
1357  }
1358  if(g_flbreak)
1359  break;
1360 #endif
1361  //if(delta_cnt > buf_dscr.blkNum)
1362  //{
1363  // printf("Delta = %d\r", delta_cnt);
1364  // err_cnt += delta_cnt - buf_dscr.blkNum;
1365  //}
1366  cur_buf = write_cnt % buf_dscr->blkNum;
1367  for(int j = 0; j < delta_cnt; j++)
1368  {
1369  //daq_buf = buf_dscr.pStub->lastBlock + 1;
1370  //if(daq_buf == buf_dscr.blkNum)
1371  // daq_buf = 0;
1372  //if(daq_buf == cur_buf)
1373  // err_cnt++;
1374  //printf("Writing %d, daq %d, total %d\n", cur_buf, daq_buf, buf_dscr.pStub->totalCounter);
1375  //DspFunc(buf_dscr->ppBlk[cur_buf], buf_dscr->blkSize);
1376  status = BRD_ctrl(hSrv, 0, BRDctrl_ADC_FIFOSTATUS, &Status);
1377  if(Status & 0x80)
1378  BRDC_printf(_BRDC("ERROR: ADC FIFO is overflow (ADC FIFO Status = 0x%04X)\n"), Status);
1379 #if defined(__IPC_WIN__) || defined(__IPC_LINUX__)
1380  IPC_writeFile(hfile, buf_dscr->ppBlk[cur_buf], buf_dscr->blkSize);
1381 #else
1382  WriteFile(hfile, buf_dscr->ppBlk[cur_buf], buf_dscr->blkSize, &nNumberOfWriteBytes, NULL);
1383 #endif
1384  cur_buf++;
1385  if(cur_buf == buf_dscr->blkNum)
1386  cur_buf = 0;
1387  write_cnt++;
1388  if(write_cnt == g_fileBufNum)
1389  break;
1390  }
1391  BRDC_printf(_BRDC("Delta = %ld, written buffers = %d, errors = %d\r"), delta_cnt, write_cnt, err_cnt);
1392  //delta_cnt = buf_dscr.pStub->totalCounter - write_cnt;
1393  //if(delta_cnt > buf_dscr.blkNum)
1394  // err_cnt += delta_cnt - 1;
1395  //if(write_cnt % 4 == 0)
1396  //{
1397  //total_cnt = buf_dscr.pStub->totalCounter;
1398  //printf("%s: Total buffers = %d, written buffers = %d\r", fileName, total_cnt, write_cnt);
1399  // printf("%s: written buffers = %d\r", fileName, write_cnt);
1400  //}
1401  }while(write_cnt < g_fileBufNum);
1402  return err_cnt;
1403 }
1404 
1405 //void DspFunc(void* buf, ULONG size)
1406 //{
1407 // USHORT* pSig = (USHORT*)buf;
1408 // int num = size >> 1;
1409 // for(int i = 0; i < num; i++)
1410 // pSig[i] += 1;
1411 //}
g_dirFileName
BRDCHAR g_dirFileName[]
Definition: adc_ctrl_data.cpp:26
g_DirWriteFile
int g_DirWriteFile
Definition: adc_ctrl_data.cpp:24
g_fileMap
int g_fileMap
Definition: adc_ctrl_data.cpp:12
CheckClock
int CheckClock(BRD_Handle hADC, BRDCHAR *AdcSrvName)
Definition: adc_ctrl.cpp:82
MultiBlkProcWrDir
int MultiBlkProcWrDir(BRD_Handle hSrv, HANDLE hfile, int idx, BRDctrl_StreamCBufAlloc *buf_dscr)
Definition: adc_ctrl.cpp:1282
DisplayError
void DisplayError(S32 status, const char *func_name, const BRDCHAR *cmd_str)
Definition: adc_ctrl.cpp:49
DaqIntoFifo
S32 DaqIntoFifo(BRD_Handle hADC, PVOID pSig, ULONG bBufSize, int DspMode)
Definition: adc_ctrl.cpp:648
THREAD_PARAM
struct _THREAD_PARAM THREAD_PARAM
g_MemAsFifo
ULONG g_MemAsFifo
Definition: adc_ctrl_data.cpp:14
MAX_CHAN
#define MAX_CHAN
Definition: adc_ctrl.h:13
g_hSRV
BRD_Handle g_hSRV
Definition: adc_ctrl_data.cpp:13
g_buf_dscr
BRDctrl_StreamCBufAlloc g_buf_dscr
Definition: adc_ctrl.cpp:25
g_flbreak
int g_flbreak
Definition: adc_ctrl.cpp:1035
g_MemDrqFlag
ULONG g_MemDrqFlag
Definition: adc_ctrl_data.cpp:16
g_samplRate
double g_samplRate
Definition: adc_ctrl_data.cpp:17
g_hPostfixFileMap
HANDLE g_hPostfixFileMap
Definition: adc_ctrl.cpp:18
AllocDaqBuf
S32 AllocDaqBuf(BRD_Handle hADC, PVOID *&pSig, unsigned long long *pbytesBufSize, ULONG bufType, ULONG *pBlkNum)
Definition: adc_ctrl.cpp:806
g_AdcSrvName
BRDCHAR g_AdcSrvName[]
Definition: adc_ctrl_data.cpp:20
SimpleProcWrDir
int SimpleProcWrDir(BRD_Handle hSrv, HANDLE hfile, int idx, BRDctrl_StreamCBufAlloc *buf_dscr)
Definition: adc_ctrl.cpp:1218
adc_ctrl.h
PTHREAD_PARAM
struct _THREAD_PARAM * PTHREAD_PARAM
_THREAD_PARAM
Definition: adc_ctrl.cpp:1018
DirectFile
void DirectFile(ULONG bufType, ULONG FileBufSize, ULONG FileBufNum, ULONG FileBlkNum)
Definition: adc_ctrl.cpp:1042
g_hBufFileMap
HANDLE * g_hBufFileMap
Definition: adc_ctrl.cpp:16
g_fileBlkNum
ULONG g_fileBlkNum
Definition: adc_ctrl.cpp:1040
DaqIntoFifoDMA
S32 DaqIntoFifoDMA(BRD_Handle hADC)
Definition: adc_ctrl.cpp:697
AdcSettings
S32 AdcSettings(BRD_Handle hADC, int idx, BRDCHAR *srvName, BRDCHAR *iniFileName)
Definition: adc_ctrl.cpp:130
g_PretrigMode
int g_PretrigMode
Definition: adc_ctrl_data.cpp:29
g_FileBufSize
ULONG g_FileBufSize
Definition: adc_ctrl_data.cpp:25
g_pPostfix
char * g_pPostfix
Definition: adc_ctrl.cpp:23
g_fileBufSize
ULONG g_fileBufSize
Definition: adc_ctrl.cpp:1038
FreeDaqBuf
S32 FreeDaqBuf(BRD_Handle hADC, ULONG blkNum)
Definition: adc_ctrl.cpp:913
g_AdcDrqFlag
ULONG g_AdcDrqFlag
Definition: adc_ctrl_data.cpp:15
g_hFlgFileMap
HANDLE g_hFlgFileMap
Definition: adc_ctrl.cpp:17
g_bufType
ULONG g_bufType
Definition: adc_ctrl.cpp:1037
_THREAD_PARAM::idx
int idx
Definition: adc_ctrl.cpp:1020
g_fileBufNum
ULONG g_fileBufNum
Definition: adc_ctrl.cpp:1039
DirWriteIntoFile
unsigned __stdcall DirWriteIntoFile(void *pParams)
Definition: adc_ctrl.cpp:1078
g_pFlags
ULONG * g_pFlags
Definition: adc_ctrl.cpp:22
_THREAD_PARAM::handle
BRD_Handle handle
Definition: adc_ctrl.cpp:1019
MapWrFlagSinc
void MapWrFlagSinc(int flg, int isNewParam)
Definition: adc_ctrl.cpp:1005
g_bBufSize
unsigned long long g_bBufSize
Definition: adc_ctrl_data.cpp:23
MapRdFlagSinc
int MapRdFlagSinc()
Definition: adc_ctrl.cpp:1012
g_samplesOfChannel
unsigned long long g_samplesOfChannel
Definition: adc_ctrl_data.cpp:22
DspFunc
void DspFunc(void *buf, ULONG size)
g_Cycle
ULONG g_Cycle
Definition: adc_ctrl_data.cpp:21
g_transRate
int g_transRate
Definition: adc_ctrl_data.cpp:28
MappingIsviParams
void MappingIsviParams(BRD_Handle hADC, unsigned long long nNumberOfBytes)
Definition: adc_ctrl.cpp:517
g_nPostTrigSamples
long long g_nPostTrigSamples
Definition: adc_ctrl_data.cpp:30
g_IoDelay
int g_IoDelay
Definition: adc_ctrl_data.cpp:18
Generated by   doxygen 1.8.14