Rev 197 | Go to most recent revision | Details | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 195 | f9daq | 1 | /********************************************************************\ |
| 2 | |||
| 3 | Name: drscl.cpp |
||
| 4 | Created by: Stefan Ritt |
||
| 5 | |||
| 6 | Contents: Command line interface to DRS chip via USB and VME |
||
| 7 | |||
| 8 | $Id: drscl.cpp 21435 2014-07-30 13:02:31Z ritt $ |
||
| 9 | |||
| 10 | \********************************************************************/ |
||
| 11 | |||
| 12 | #include <math.h> |
||
| 13 | |||
| 14 | #ifdef _MSC_VER |
||
| 15 | |||
| 16 | #include <windows.h> |
||
| 17 | #include <conio.h> |
||
| 18 | #include <io.h> |
||
| 19 | #include <direct.h> |
||
| 20 | |||
| 21 | #define DIR_SEPARATOR '\\' |
||
| 22 | |||
| 23 | #elif defined(OS_LINUX) || defined(OS_DARWIN) |
||
| 24 | |||
| 25 | #define O_BINARY 0 |
||
| 26 | |||
| 27 | #include <unistd.h> |
||
| 28 | #include <ctype.h> |
||
| 29 | #include <sys/ioctl.h> |
||
| 30 | #include <errno.h> |
||
| 31 | |||
| 32 | #define DIR_SEPARATOR '/' |
||
| 33 | |||
| 34 | #endif |
||
| 35 | |||
| 36 | #include <stdio.h> |
||
| 37 | #include <string.h> |
||
| 38 | #include <stdlib.h> |
||
| 39 | #include <fcntl.h> |
||
| 40 | #include <time.h> |
||
| 41 | #include <sys/stat.h> |
||
| 42 | #include <assert.h> |
||
| 43 | |||
| 44 | #include "strlcpy.h" |
||
| 45 | #include "DRS.h" |
||
| 46 | #ifdef HAVE_VME |
||
| 47 | #include "ace.h" |
||
| 48 | #endif |
||
| 49 | |||
| 50 | const char *drscl_svn_revision = "$Id: drscl.cpp 21435 2014-07-30 13:02:31Z ritt $"; |
||
| 51 | |||
| 52 | void print_help(); |
||
| 53 | void clear_screen(); |
||
| 54 | int match(const char *str, const char *cmd); |
||
| 55 | void cmd_loop(); |
||
| 56 | |||
| 57 | #if defined(OS_LINUX) || defined(OS_DARWIN) |
||
| 58 | #define getch() getchar() |
||
| 59 | #define Sleep(x) usleep(x*1000) |
||
| 60 | #endif |
||
| 61 | |||
| 62 | #ifdef _MSC_VER |
||
| 63 | #include <conio.h> |
||
| 64 | #define drs_kbhit() kbhit() |
||
| 65 | #endif |
||
| 66 | |||
| 67 | void print_help() |
||
| 68 | { |
||
| 69 | puts("Available commands:\n"); |
||
| 70 | puts("active <0|1> Set domino active mode on (1) or off (0)"); |
||
| 71 | puts("board <i>|<i1> <i2>|all Address individual board/range/all boards"); |
||
| 72 | puts("calib [dir] Response Calibration. Use dir=\"area\" for MEG"); |
||
| 73 | puts("chn [n] Set number of channels: 8, 4, 2, 1"); |
||
| 74 | puts("ct Chip Test"); |
||
| 75 | puts("del <0|1> Switch delayed start on/off"); |
||
| 76 | puts("dir Show CF directory"); |
||
| 77 | puts("dmode <0|1> Set Domino mode 0=single, 1=cont."); |
||
| 78 | puts("et EEPROM test"); |
||
| 79 | puts("exit Exit program"); |
||
| 80 | puts("freq <ghz> [0|1] Set frequency of board [without/with] regulation"); |
||
| 81 | puts("info Show information about board"); |
||
| 82 | puts("init Initialize board"); |
||
| 83 | puts("led <0|1> Turn LED on (1) or off (0)"); |
||
| 84 | puts("lock [0|1] Display lock status [without/with] restart"); |
||
| 85 | puts("multi [0|1] Turn multi-buffer mode on/off"); |
||
| 86 | puts("offset <voltage> Set offset voltage"); |
||
| 87 | puts("phase <value> [0|1] Set ADC clock phase and inversion"); |
||
| 88 | puts("quit Exit program"); |
||
| 89 | puts("ram Test speed to FPGA RAM"); |
||
| 90 | puts("range <center> Change input range to <center>+=0.5V"); |
||
| 91 | puts("read <chn> [0|1] [file] Read waveform to [file], chn=0..19 [with] calibration"); |
||
| 92 | puts("refclk [0|1] Use FPGA ref. clk (0) or ext. P2 ref. clk (1)"); |
||
| 93 | puts("reg Register test"); |
||
| 94 | puts("serial <number> Set serial number of board"); |
||
| 95 | puts("scan Scan for boards"); |
||
| 96 | puts("standby <0|1> Turn standby mode on (1) or off (0)"); |
||
| 97 | puts("start Start domino wave"); |
||
| 98 | puts("stop Issue soft trigger"); |
||
| 99 | puts("tcout [file] [idx_offset] Print time calibration of DRS4, or write it onto [file]"); |
||
| 100 | puts("tcs <0|1> Timing calibration signal on (1) or off (0)"); |
||
| 101 | puts("tcalib [freq] Timing Calibration"); |
||
| 102 | puts("tlevel <voltage> Set trigger level in Volts"); |
||
| 103 | puts("trans <0|1> Set transparent mode on (1) or off (0)"); |
||
| 104 | puts("trig <0|1> Hardware trigger on (1) or off (0)"); |
||
| 105 | puts("upload <file> Upload ACE file to CF"); |
||
| 106 | puts("volt off|<voltage> Turn calibration voltage on/off"); |
||
| 107 | |||
| 108 | puts(""); |
||
| 109 | } |
||
| 110 | |||
| 111 | /*------------------------------------------------------------------*/ |
||
| 112 | |||
| 113 | void clear_screen() |
||
| 114 | { |
||
| 115 | #ifdef _MSC_VER |
||
| 116 | |||
| 117 | HANDLE hConsole; |
||
| 118 | COORD coordScreen = { 0, 0 }; /* here's where we'll home the cursor */ |
||
| 119 | BOOL bSuccess; |
||
| 120 | DWORD cCharsWritten; |
||
| 121 | CONSOLE_SCREEN_BUFFER_INFO csbi; /* to get buffer info */ |
||
| 122 | DWORD dwConSize; /* number of character cells in the current buffer */ |
||
| 123 | |||
| 124 | hConsole = GetStdHandle(STD_OUTPUT_HANDLE); |
||
| 125 | |||
| 126 | /* get the number of character cells in the current buffer */ |
||
| 127 | bSuccess = GetConsoleScreenBufferInfo(hConsole, &csbi); |
||
| 128 | dwConSize = csbi.dwSize.X * csbi.dwSize.Y; |
||
| 129 | |||
| 130 | /* fill the entire screen with blanks */ |
||
| 131 | bSuccess = FillConsoleOutputCharacter(hConsole, (TCHAR) ' ', dwConSize, coordScreen, &cCharsWritten); |
||
| 132 | |||
| 133 | /* put the cursor at (0, 0) */ |
||
| 134 | bSuccess = SetConsoleCursorPosition(hConsole, coordScreen); |
||
| 135 | return; |
||
| 136 | |||
| 137 | #else |
||
| 138 | printf("\033[2J"); |
||
| 139 | #endif |
||
| 140 | } |
||
| 141 | |||
| 142 | /*------------------------------------------------------------------*/ |
||
| 143 | |||
| 144 | int match(const char *str, const char *cmd) |
||
| 145 | { |
||
| 146 | int i; |
||
| 147 | |||
| 148 | if (str[0] == '\r' || str[0] == '\n') |
||
| 149 | return 0; |
||
| 150 | |||
| 151 | for (i = 0; i < (int) strlen(str); i++) { |
||
| 152 | if (toupper(str[i]) != toupper(cmd[i]) && str[i] != '\r' && str[i] != '\n') |
||
| 153 | return 0; |
||
| 154 | } |
||
| 155 | |||
| 156 | return 1; |
||
| 157 | } |
||
| 158 | |||
| 159 | /*------------------------------------------------------------------*/ |
||
| 160 | |||
| 161 | class ProgressBar : public DRSCallback |
||
| 162 | { |
||
| 163 | public: |
||
| 164 | void Progress(int prog); |
||
| 165 | }; |
||
| 166 | |||
| 167 | void ProgressBar::Progress(int prog) |
||
| 168 | { |
||
| 169 | if (prog == 0) |
||
| 170 | printf("[--------------------------------------------------]\r"); |
||
| 171 | printf("["); |
||
| 172 | for (int i=0 ; i<prog/2 ; i++) |
||
| 173 | printf("="); |
||
| 174 | printf("\r"); |
||
| 175 | fflush(stdout); |
||
| 176 | } |
||
| 177 | |||
| 178 | /*------------------------------------------------------------------*/ |
||
| 179 | |||
| 180 | void cmd_loop() |
||
| 181 | { |
||
| 182 | int i, j, idx, i_start, i_end, nparam, calib, status, debug, cascading, |
||
| 183 | ext_refclk; |
||
| 184 | char str[256], dir[256], line[256], file_name[256], param[10][100], *pc; |
||
| 185 | double freq, triggerfreq, range; |
||
| 186 | FILE *f = NULL; |
||
| 187 | DRS *drs; |
||
| 188 | DRSBoard *b; |
||
| 189 | #ifdef HAVE_VME |
||
| 190 | ACE ace; |
||
| 191 | #endif |
||
| 192 | static char bar[] = {'\\', '|', '/', '-'}; |
||
| 193 | |||
| 194 | /* do initial scan */ |
||
| 195 | drs = new DRS(); |
||
| 196 | if (drs->GetError(str, sizeof(str))) |
||
| 197 | printf("%s", str); |
||
| 198 | |||
| 199 | for (i=0 ; i<drs->GetNumberOfBoards() ; i++) { |
||
| 200 | b = drs->GetBoard(i); |
||
| 201 | #ifdef HAVE_VME |
||
| 202 | if (b->GetTransport() != 1) |
||
| 203 | printf("Found DRS%d board %2d on USB, serial #%04d, firmware revision %5d\n", |
||
| 204 | b->GetDRSType(), i, b->GetBoardSerialNumber(), b->GetFirmwareVersion()); |
||
| 205 | #else |
||
| 206 | printf("Found DRS%d board %2d on USB, serial #%04d, firmware revision %5d\n", |
||
| 207 | b->GetDRSType(), i, b->GetBoardSerialNumber(), b->GetFirmwareVersion()); |
||
| 208 | #endif |
||
| 209 | } |
||
| 210 | |||
| 211 | if (drs->GetNumberOfBoards()) { |
||
| 212 | i_start = 0; |
||
| 213 | i_end = 1; |
||
| 214 | b = drs->GetBoard(0); |
||
| 215 | } |
||
| 216 | else { |
||
| 217 | printf("No DRS Boards found\n"); |
||
| 218 | i_start = i_end = 0; |
||
| 219 | b = NULL; |
||
| 220 | } |
||
| 221 | |||
| 222 | puts(""); |
||
| 223 | |||
| 224 | do { |
||
| 225 | /* print prompt */ |
||
| 226 | if (i_start == i_end-1) |
||
| 227 | printf("B%d> ", i_start); |
||
| 228 | else if (i_start == 0 && i_end == 0) |
||
| 229 | printf("> "); |
||
| 230 | else |
||
| 231 | printf("B%d-%d> ", i_start, i_end-1); |
||
| 232 | memset(line, 0, sizeof(line)); |
||
| 233 | fgets(line, sizeof(line), stdin); |
||
| 234 | /* strip \r\n */ |
||
| 235 | while (strpbrk(line,"\n\r")) |
||
| 236 | *strpbrk(line,"\n\r") = 0; |
||
| 237 | |||
| 238 | /* analyze line */ |
||
| 239 | nparam = 0; |
||
| 240 | pc = line; |
||
| 241 | while (*pc == ' ') |
||
| 242 | pc++; |
||
| 243 | |||
| 244 | memset(param, 0, sizeof(param)); |
||
| 245 | do { |
||
| 246 | if (*pc == '"') { |
||
| 247 | pc++; |
||
| 248 | for (i = 0; *pc && *pc != '"'; i++) |
||
| 249 | param[nparam][i] = *pc++; |
||
| 250 | if (*pc) |
||
| 251 | pc++; |
||
| 252 | } else if (*pc == '\'') { |
||
| 253 | pc++; |
||
| 254 | for (i = 0; *pc && *pc != '\''; i++) |
||
| 255 | param[nparam][i] = *pc++; |
||
| 256 | if (*pc) |
||
| 257 | pc++; |
||
| 258 | } else if (*pc == '`') { |
||
| 259 | pc++; |
||
| 260 | for (i = 0; *pc && *pc != '`'; i++) |
||
| 261 | param[nparam][i] = *pc++; |
||
| 262 | if (*pc) |
||
| 263 | pc++; |
||
| 264 | } else |
||
| 265 | for (i = 0; *pc && *pc != ' '; i++) |
||
| 266 | param[nparam][i] = *pc++; |
||
| 267 | param[nparam][i] = 0; |
||
| 268 | while (*pc == ' ' || *pc == '\r' || *pc == '\n') |
||
| 269 | pc++; |
||
| 270 | nparam++; |
||
| 271 | } while (*pc); |
||
| 272 | |||
| 273 | if (param[0][0] == 0) { |
||
| 274 | } |
||
| 275 | |||
| 276 | /* help ---------- */ |
||
| 277 | else if ((param[0][0] == 'h' && param[0][1] == 'e') || param[0][0] == '?') |
||
| 278 | print_help(); |
||
| 279 | |||
| 280 | /* scan ---------- */ |
||
| 281 | else if (match(param[0], "scan")) { |
||
| 282 | j = 0; |
||
| 283 | |||
| 284 | do { |
||
| 285 | delete drs; |
||
| 286 | drs = new DRS(); |
||
| 287 | |||
| 288 | for (i=0 ; i<drs->GetNumberOfBoards() ; i++) { |
||
| 289 | b = drs->GetBoard(i); |
||
| 290 | #ifdef HAVE_VME |
||
| 291 | if (b->GetTransport() != 1) |
||
| 292 | printf("Found DRS%d board %2d on USB, serial #%04d, firmware revision %5d\n", |
||
| 293 | b->GetDRSType(), i, b->GetBoardSerialNumber(), b->GetFirmwareVersion()); |
||
| 294 | #else |
||
| 295 | printf("Found DRS%d board %2d on USB, serial #%04d, firmware revision %5d\n", |
||
| 296 | b->GetDRSType(), i, b->GetBoardSerialNumber(), b->GetFirmwareVersion()); |
||
| 297 | #endif |
||
| 298 | } |
||
| 299 | |||
| 300 | if (drs_kbhit()) |
||
| 301 | break; |
||
| 302 | |||
| 303 | if (param[1][0] == 'r') { |
||
| 304 | printf("%c\r", bar[j]); |
||
| 305 | fflush(stdout); |
||
| 306 | j = (j+1) % 4; |
||
| 307 | Sleep(1000); |
||
| 308 | } |
||
| 309 | |||
| 310 | } while (param[1][0] == 'r'); |
||
| 311 | |||
| 312 | while (drs_kbhit()) |
||
| 313 | getch(); |
||
| 314 | |||
| 315 | if (drs->GetNumberOfBoards()) { |
||
| 316 | i_start = 0; |
||
| 317 | i_end = 1; |
||
| 318 | b = drs->GetBoard(0); |
||
| 319 | } else { |
||
| 320 | printf("No DRS Boards found\n"); |
||
| 321 | i_start = i_end = 0; |
||
| 322 | b = NULL; |
||
| 323 | } |
||
| 324 | } |
||
| 325 | |||
| 326 | /* address board ---------- */ |
||
| 327 | else if (match(param[0], "board")) { |
||
| 328 | if (param[1][0] == 'a') { |
||
| 329 | i_start = 0; |
||
| 330 | i_end = drs->GetNumberOfBoards(); |
||
| 331 | b = drs->GetBoard(0); |
||
| 332 | } else if (param[2][0] && atoi(param[2]) > 0 && atoi(param[2]) < drs->GetNumberOfBoards()) { |
||
| 333 | i_start = atoi(param[1]); |
||
| 334 | i_end = atoi(param[2]) + 1; |
||
| 335 | b = drs->GetBoard(i_start); |
||
| 336 | } else if (atoi(param[1]) >= 0 && atoi(param[1]) < drs->GetNumberOfBoards()) { |
||
| 337 | i_start = atoi(param[1]); |
||
| 338 | i_end = i_start + 1; |
||
| 339 | b = drs->GetBoard(i_start); |
||
| 340 | } else |
||
| 341 | printf("Board #%d does not exist\n", atoi(param[1])); |
||
| 342 | } |
||
| 343 | |||
| 344 | /* info ---------- */ |
||
| 345 | else if (match(param[0], "info")) { |
||
| 346 | for (idx=i_start ; idx<i_end ; idx++) { |
||
| 347 | b = drs->GetBoard(idx); |
||
| 348 | printf("==============================\n"); |
||
| 349 | printf("Mezz. Board index: %d\n", idx); |
||
| 350 | #ifdef HAVE_VME |
||
| 351 | if (b->GetTransport() == TR_VME) { |
||
| 352 | printf("Slot: %d", (b->GetSlotNumber() >> 1)+2); |
||
| 353 | if ((b->GetSlotNumber() & 1) == 0) |
||
| 354 | printf(" upper\n"); |
||
| 355 | else |
||
| 356 | printf(" lower\n"); |
||
| 357 | } |
||
| 358 | #endif |
||
| 359 | printf("DRS type: DRS%d\n", b->GetDRSType()); |
||
| 360 | printf("Board type: %d\n", b->GetBoardType()); |
||
| 361 | printf("Serial number: %04d\n", b->GetBoardSerialNumber()); |
||
| 362 | printf("Firmware revision: %d\n", b->GetFirmwareVersion()); |
||
| 363 | printf("Temperature: %1.1lf C\n", b->GetTemperature()); |
||
| 364 | if (b->GetDRSType() == 4) { |
||
| 365 | printf("Input range: %1.2lgV...%1.2lgV\n", |
||
| 366 | b->GetInputRange()-0.5, b->GetInputRange()+0.5); |
||
| 367 | printf("Calibrated range: %1.2lgV...%1.2lgV\n", b->GetCalibratedInputRange()-0.5, |
||
| 368 | b->GetCalibratedInputRange()+0.5); |
||
| 369 | printf("Calibrated frequency: %1.3lf GHz\n", b->GetCalibratedFrequency()); |
||
| 370 | |||
| 371 | if (b->GetTransport() == TR_VME) { |
||
| 372 | printf("Multi Buffer WP: %d\n", b->GetMultiBufferWP()); |
||
| 373 | printf("Multi Buffer RP: %d\n", b->GetMultiBufferRP()); |
||
| 374 | } |
||
| 375 | } |
||
| 376 | |||
| 377 | printf("Status reg.: %08X\n", b->GetStatusReg()); |
||
| 378 | if (b->GetStatusReg() & BIT_RUNNING) |
||
| 379 | puts(" Domino wave running"); |
||
| 380 | if (b->GetDRSType() == 4) { |
||
| 381 | if (b->GetBoardType() == 5) { |
||
| 382 | if (b->GetStatusReg() & BIT_PLL_LOCKED0) |
||
| 383 | puts(" PLL locked"); |
||
| 384 | } else if (b->GetBoardType() == 6) { |
||
| 385 | i = 0; |
||
| 386 | if (b->GetStatusReg() & BIT_PLL_LOCKED0) i++; |
||
| 387 | if (b->GetStatusReg() & BIT_PLL_LOCKED1) i++; |
||
| 388 | if (b->GetStatusReg() & BIT_PLL_LOCKED2) i++; |
||
| 389 | if (b->GetStatusReg() & BIT_PLL_LOCKED3) i++; |
||
| 390 | if (i == 4) |
||
| 391 | puts(" All PLLs locked"); |
||
| 392 | else if (i == 0) |
||
| 393 | puts(" No PLL locked"); |
||
| 394 | else |
||
| 395 | printf(" %d PLLs locked\n", i); |
||
| 396 | if (b->GetStatusReg() & BIT_LMK_LOCKED) |
||
| 397 | puts(" LMK PLL locked"); |
||
| 398 | } |
||
| 399 | } else { |
||
| 400 | if (b->GetStatusReg() & BIT_NEW_FREQ1) |
||
| 401 | puts(" New Freq1 ready"); |
||
| 402 | if (b->GetStatusReg() & BIT_NEW_FREQ2) |
||
| 403 | puts(" New Freq2 ready"); |
||
| 404 | } |
||
| 405 | |||
| 406 | printf("Control reg.: %08X\n", b->GetCtrlReg()); |
||
| 407 | if (b->GetCtrlReg() & BIT_MULTI_BUFFER) |
||
| 408 | puts(" Multi-buffering enabled"); |
||
| 409 | if (b->GetDRSType() == 4) { |
||
| 410 | if (b->GetConfigReg() & BIT_CONFIG_DMODE) |
||
| 411 | puts(" DMODE circular"); |
||
| 412 | else |
||
| 413 | puts(" DMODE single shot"); |
||
| 414 | } else { |
||
| 415 | if (b->GetCtrlReg() & BIT_DMODE) |
||
| 416 | puts(" DMODE circular"); |
||
| 417 | else |
||
| 418 | puts(" DMODE single shot"); |
||
| 419 | } |
||
| 420 | if (b->GetCtrlReg() & BIT_LED) |
||
| 421 | puts(" LED"); |
||
| 422 | if (b->GetCtrlReg() & BIT_TCAL_EN) |
||
| 423 | puts(" TCAL enabled"); |
||
| 424 | if (b->GetDRSType() == 4) { |
||
| 425 | if (b->GetCtrlReg() & BIT_TRANSP_MODE) |
||
| 426 | puts(" TRANSP_MODE enabled"); |
||
| 427 | } else { |
||
| 428 | if (b->GetCtrlReg() & BIT_FREQ_AUTO_ADJ) |
||
| 429 | puts(" FREQ_AUTO_ADJ enabled"); |
||
| 430 | } |
||
| 431 | if (b->GetCtrlReg() & BIT_ENABLE_TRIGGER1) |
||
| 432 | puts(" Hardware trigger enabled"); |
||
| 433 | if (b->GetDRSType() == 4) { |
||
| 434 | if (b->GetCtrlReg() & BIT_READOUT_MODE) |
||
| 435 | puts(" Readout from stop"); |
||
| 436 | if (b->GetCtrlReg() & BIT_ENABLE_TRIGGER2) |
||
| 437 | puts(" Internal trigger enabled"); |
||
| 438 | } else { |
||
| 439 | if (b->GetCtrlReg() & BIT_LONG_START_PULSE) |
||
| 440 | puts(" LONG_START_PULSE"); |
||
| 441 | } |
||
| 442 | if (b->GetCtrlReg() & BIT_DELAYED_START) |
||
| 443 | puts(" DELAYED_START"); |
||
| 444 | if (b->GetCtrlReg() & BIT_ACAL_EN) |
||
| 445 | puts(" ACAL enabled"); |
||
| 446 | if (b->GetDRSType() < 4) |
||
| 447 | if (b->GetCtrlReg() & BIT_TRIGGER_DELAYED) |
||
| 448 | puts(" DELAYED_TRIGGER selected"); |
||
| 449 | if (b->GetBoardType() != 5) |
||
| 450 | printf("Trigger bus: %08X\n", b->GetTriggerBus()); |
||
| 451 | if (b->GetDRSType() == 4) { |
||
| 452 | if (b->GetRefclk() == 1) { |
||
| 453 | if (b->IsPLLLocked() && b->IsLMKLocked()) { |
||
| 454 | b->ReadFrequency(0, &freq); |
||
| 455 | printf("Frequency: %1.3lf GHz\n", freq); |
||
| 456 | } else { |
||
| 457 | if (!b->IsPLLLocked()) |
||
| 458 | printf("Frequency: PLL not locked\n"); |
||
| 459 | else |
||
| 460 | printf("Frequency: LMK chip not locked\n"); |
||
| 461 | } |
||
| 462 | } else { |
||
| 463 | if (b->IsPLLLocked()) { |
||
| 464 | b->ReadFrequency(0, &freq); |
||
| 465 | printf("Frequency: %1.3lf GHz\n", freq); |
||
| 466 | } else { |
||
| 467 | printf("Frequency: PLL not locked\n"); |
||
| 468 | } |
||
| 469 | } |
||
| 470 | } else { |
||
| 471 | if (b->IsBusy()) { |
||
| 472 | b->ReadFrequency(0, &freq); |
||
| 473 | printf("Frequency0: %1.4lf GHz\n", freq); |
||
| 474 | b->ReadFrequency(1, &freq); |
||
| 475 | printf("Frequency1: %1.4lf GHz\n", freq); |
||
| 476 | } else |
||
| 477 | puts("Domino wave stopped"); |
||
| 478 | } |
||
| 479 | } |
||
| 480 | } |
||
| 481 | |||
| 482 | /* init ---------- */ |
||
| 483 | else if (match(param[0], "init")) { |
||
| 484 | for (i=i_start ; i<i_end ; i++) { |
||
| 485 | b = drs->GetBoard(i); |
||
| 486 | b->Init(); |
||
| 487 | } |
||
| 488 | } |
||
| 489 | |||
| 490 | /* set led ---------- */ |
||
| 491 | else if (match(param[0], "led")) { |
||
| 492 | for (i=i_start ; i<i_end ; i++) { |
||
| 493 | b = drs->GetBoard(i); |
||
| 494 | if (atoi(param[1])) |
||
| 495 | b->SetLED(1); |
||
| 496 | else |
||
| 497 | b->SetLED(0); |
||
| 498 | } |
||
| 499 | } |
||
| 500 | |||
| 501 | /* set multi buffer mode ---------- */ |
||
| 502 | else if (match(param[0], "multi")) { |
||
| 503 | for (i=i_start ; i<i_end ; i++) { |
||
| 504 | b = drs->GetBoard(i); |
||
| 505 | if (atoi(param[1])) |
||
| 506 | b->SetMultiBuffer(1); |
||
| 507 | else |
||
| 508 | b->SetMultiBuffer(0); |
||
| 509 | } |
||
| 510 | } |
||
| 511 | |||
| 512 | /* lock status ---------- */ |
||
| 513 | else if (match(param[0], "lock")) { |
||
| 514 | int slot, found, restart; |
||
| 515 | |||
| 516 | restart = atoi(param[1]); |
||
| 517 | |||
| 518 | // select external reference clock |
||
| 519 | for (i=0 ; i<drs->GetNumberOfBoards() ; i++) { |
||
| 520 | b = drs->GetBoard(i); |
||
| 521 | b->SetRefclk(1); |
||
| 522 | b->SetFrequency(b->GetNominalFrequency(), true); |
||
| 523 | } |
||
| 524 | |||
| 525 | // loop until keyboard hit |
||
| 526 | do { |
||
| 527 | clear_screen(); |
||
| 528 | printf(" 1 1 1 1 1 1 1 1 1 1 2 2\n"); |
||
| 529 | printf("2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1\n\n"); |
||
| 530 | |||
| 531 | // upper slots |
||
| 532 | for (slot = 2 ; slot<22 ; slot++) { |
||
| 533 | found = 0; |
||
| 534 | for (i=0 ; i<drs->GetNumberOfBoards() ; i++) { |
||
| 535 | b = drs->GetBoard(i); |
||
| 536 | if ((b->GetSlotNumber() & 1) == 0 && (b->GetSlotNumber() >> 1)+2 == slot) { |
||
| 537 | found = 1; |
||
| 538 | if (b->IsLMKLocked()) |
||
| 539 | printf("O "); |
||
| 540 | else |
||
| 541 | printf("- "); |
||
| 542 | } |
||
| 543 | } |
||
| 544 | if (!found) |
||
| 545 | printf(" "); |
||
| 546 | } |
||
| 547 | printf("\n"); |
||
| 548 | |||
| 549 | // lower slots |
||
| 550 | for (slot = 2 ; slot<22 ; slot++) { |
||
| 551 | found = 0; |
||
| 552 | for (i=0 ; i<drs->GetNumberOfBoards() ; i++) { |
||
| 553 | b = drs->GetBoard(i); |
||
| 554 | if ((b->GetSlotNumber() & 1) == 1 && (b->GetSlotNumber() >> 1)+2 == slot) { |
||
| 555 | found = 1; |
||
| 556 | if (b->IsLMKLocked()) |
||
| 557 | printf("O "); |
||
| 558 | else |
||
| 559 | printf("- "); |
||
| 560 | } |
||
| 561 | } |
||
| 562 | if (!found) |
||
| 563 | printf(" "); |
||
| 564 | } |
||
| 565 | printf("\n"); |
||
| 566 | |||
| 567 | if (restart) { |
||
| 568 | for (i=0 ; i<drs->GetNumberOfBoards() ; i++) { |
||
| 569 | b = drs->GetBoard(i); |
||
| 570 | b->SetFrequency(b->GetNominalFrequency(), true); |
||
| 571 | } |
||
| 572 | } |
||
| 573 | |||
| 574 | Sleep(300); |
||
| 575 | |||
| 576 | } while (!drs_kbhit()); |
||
| 577 | puts(""); |
||
| 578 | while (drs_kbhit()) |
||
| 579 | getch(); |
||
| 580 | } |
||
| 581 | |||
| 582 | /* start domino wave ---------- */ |
||
| 583 | else if (match(param[0], "start")) { |
||
| 584 | for (i=i_start ; i<i_end ; i++) { |
||
| 585 | b = drs->GetBoard(i); |
||
| 586 | b->StartDomino(); |
||
| 587 | b->ReadFrequency(0, &freq); |
||
| 588 | for (j=0 ; j<10 ; j++) |
||
| 589 | if (b->GetDRSType() != 4 || b->IsPLLLocked()) |
||
| 590 | break; |
||
| 591 | if (j == 10) |
||
| 592 | printf("Domino wave started but PLL did not lock!\n"); |
||
| 593 | else |
||
| 594 | printf("Domino wave started at %1.3lf GHz\n", freq); |
||
| 595 | } |
||
| 596 | } |
||
| 597 | |||
| 598 | /* issue soft trigger ---------- */ |
||
| 599 | else if (match(param[0], "stop")) { |
||
| 600 | for (i=i_start ; i<i_end ; i++) { |
||
| 601 | b = drs->GetBoard(i); |
||
| 602 | b->SoftTrigger(); |
||
| 603 | } |
||
| 604 | } |
||
| 605 | |||
| 606 | /* set serial ---------- */ |
||
| 607 | else if (match(param[0], "serial")) { |
||
| 608 | for (i=i_start ; i<i_end ; i++) { |
||
| 609 | b = drs->GetBoard(i); |
||
| 610 | if (param[1][0] == 0) { |
||
| 611 | printf("Serial number: "); |
||
| 612 | fgets(str, sizeof(str), stdin); |
||
| 613 | } else |
||
| 614 | strlcpy(str, param[1], sizeof(str)); |
||
| 615 | |||
| 616 | if (!b->SetBoardSerialNumber(atoi(str))) |
||
| 617 | printf("Board EEPROM is write protected\n"); |
||
| 618 | else |
||
| 619 | printf("Serial number successfully changed\n"); |
||
| 620 | } |
||
| 621 | } |
||
| 622 | |||
| 623 | /* eeprom test ---------- */ |
||
| 624 | else if (match(param[0], "et")) { |
||
| 625 | unsigned short buf[16384]; |
||
| 626 | unsigned short rbuf[16384]; |
||
| 627 | int n_error; |
||
| 628 | |||
| 629 | do { |
||
| 630 | for (i=0 ; i<16384 ; i++) |
||
| 631 | buf[i] = rand(); |
||
| 632 | b->WriteEEPROM(1, buf, sizeof(buf)); |
||
| 633 | memset(rbuf, 0, sizeof(rbuf)); |
||
| 634 | b->Write(T_RAM, 0, rbuf, sizeof(rbuf)); |
||
| 635 | b->ReadEEPROM(1, rbuf, sizeof(rbuf)); |
||
| 636 | for (i=n_error=0 ; i<16384 ; i++) |
||
| 637 | if (buf[i] != rbuf[i]) { |
||
| 638 | printf("%04X %04X - %04X\n", i, buf[i], rbuf[i]); |
||
| 639 | n_error++; |
||
| 640 | } |
||
| 641 | |||
| 642 | printf("32 kb written, %d errors\n", n_error); |
||
| 643 | } while (!drs_kbhit()); |
||
| 644 | |||
| 645 | while (drs_kbhit()) |
||
| 646 | getch(); |
||
| 647 | } |
||
| 648 | |||
| 649 | /* set frequency ---------- */ |
||
| 650 | else if (match(param[0], "freq")) { |
||
| 651 | for (i=i_start ; i<i_end ; i++) { |
||
| 652 | b = drs->GetBoard(i); |
||
| 653 | if (param[1][0] == 0) { |
||
| 654 | printf("Frequency: "); |
||
| 655 | fgets(str, sizeof(str), stdin); |
||
| 656 | } else |
||
| 657 | strlcpy(str, param[1], sizeof(str)); |
||
| 658 | |||
| 659 | b->SetDebug(1); |
||
| 660 | |||
| 661 | if (param[2][0] && atoi(param[2])) |
||
| 662 | b->RegulateFrequency(atof(str)); |
||
| 663 | else |
||
| 664 | b->SetFrequency(atof(str), true); |
||
| 665 | } |
||
| 666 | } |
||
| 667 | |||
| 668 | /* set calibration voltage ---------- */ |
||
| 669 | else if (match(param[0], "volt")) { |
||
| 670 | for (i=i_start ; i<i_end ; i++) { |
||
| 671 | b = drs->GetBoard(i); |
||
| 672 | if (param[1][0] == 0) { |
||
| 673 | printf("Voltage or \"off\": "); |
||
| 674 | fgets(str, sizeof(str), stdin); |
||
| 675 | } else |
||
| 676 | strlcpy(str, param[1], sizeof(str)); |
||
| 677 | |||
| 678 | if (str[0] == 'o') { |
||
| 679 | b->EnableAcal(0, 0); |
||
| 680 | puts("Calibration voltage turned off"); |
||
| 681 | } else { |
||
| 682 | b->EnableAcal(1, atof(str)); |
||
| 683 | printf("Voltage set to %1.3lf Volt\n", atof(str)); |
||
| 684 | } |
||
| 685 | } |
||
| 686 | } |
||
| 687 | |||
| 688 | /* set channel configuration ---------- */ |
||
| 689 | else if (match(param[0], "chn")) { |
||
| 690 | for (i=i_start ; i<i_end ; i++) { |
||
| 691 | b = drs->GetBoard(i); |
||
| 692 | if (param[1][0] == 0) { |
||
| 693 | printf("Number of channels (8,4,2,1): "); |
||
| 694 | fgets(str, sizeof(str), stdin); |
||
| 695 | } else |
||
| 696 | strlcpy(str, param[1], sizeof(str)); |
||
| 697 | |||
| 698 | if (b->SetChannelConfig(0, 8, atoi(str))) |
||
| 699 | printf("DRS4 configured for %d channels\n", atoi(str)); |
||
| 700 | } |
||
| 701 | } |
||
| 702 | |||
| 703 | /* set trigger level ---------- */ |
||
| 704 | else if (match(param[0], "tlevel")) { |
||
| 705 | for (i=i_start ; i<i_end ; i++) { |
||
| 706 | b = drs->GetBoard(i); |
||
| 707 | if (param[1][0] == 0) { |
||
| 708 | printf("Voltage: "); |
||
| 709 | fgets(str, sizeof(str), stdin); |
||
| 710 | } else |
||
| 711 | strlcpy(str, param[1], sizeof(str)); |
||
| 712 | |||
| 713 | b->SetTriggerLevel(atof(str)); |
||
| 714 | printf("Trigger level set to %1.3lf Volt\n", atof(str)); |
||
| 715 | } |
||
| 716 | } |
||
| 717 | |||
| 718 | /* trigger on/off ---------- */ |
||
| 719 | else if (match(param[0], "trig")) { |
||
| 720 | for (i=i_start ; i<i_end ; i++) { |
||
| 721 | b = drs->GetBoard(i); |
||
| 722 | b->EnableTrigger(atoi(param[1]), 0); |
||
| 723 | if (atoi(param[1]) == 1) { |
||
| 724 | puts("Hardware fast trigger is on"); |
||
| 725 | } else if (atoi(param[1]) == 2) { |
||
| 726 | puts("Hardware slow trigger is on"); |
||
| 727 | } else { |
||
| 728 | puts("Hardware trigger is off"); |
||
| 729 | } |
||
| 730 | } |
||
| 731 | } |
||
| 732 | |||
| 733 | /* timing calibration signal on/off ---------- */ |
||
| 734 | else if (match(param[0], "tcs")) { |
||
| 735 | for (i=i_start ; i<i_end ; i++) { |
||
| 736 | b = drs->GetBoard(i); |
||
| 737 | b->EnableTcal(atoi(param[1]), 0, 0); |
||
| 738 | b->SelectClockSource(0); |
||
| 739 | if (atoi(param[1])) |
||
| 740 | puts("Timing calibration signal is on"); |
||
| 741 | else |
||
| 742 | puts("Timing calibration signal is off"); |
||
| 743 | } |
||
| 744 | } |
||
| 745 | |||
| 746 | /* timing calibration signal on/off ---------- */ |
||
| 747 | else if (match(param[0], "refclk")) { |
||
| 748 | for (i=i_start ; i<i_end ; i++) { |
||
| 749 | b = drs->GetBoard(i); |
||
| 750 | b->SetRefclk(atoi(param[1])); |
||
| 751 | // re-set frequency since LMK configuration needs to be changed |
||
| 752 | b->SetFrequency(b->GetNominalFrequency(), true); |
||
| 753 | if (atoi(param[1])) |
||
| 754 | puts("Refclock set to external through P2"); |
||
| 755 | else |
||
| 756 | puts("Refclock set to internal (FPGA)"); |
||
| 757 | } |
||
| 758 | } |
||
| 759 | |||
| 760 | /* domino mode 0/1 ---------- */ |
||
| 761 | else if (match(param[0], "dmode")) { |
||
| 762 | for (i=i_start ; i<i_end ; i++) { |
||
| 763 | b = drs->GetBoard(i); |
||
| 764 | if (atoi(param[1]) == 1) { |
||
| 765 | b->SetDominoMode(1); |
||
| 766 | puts("Domino mode switched to cyclic"); |
||
| 767 | } else { |
||
| 768 | b->SetDominoMode(0); |
||
| 769 | puts("Domino mode switched to single shot"); |
||
| 770 | } |
||
| 771 | } |
||
| 772 | } |
||
| 773 | |||
| 774 | /* active mode 0/1 ---------- */ |
||
| 775 | else if (match(param[0], "active")) { |
||
| 776 | for (i=i_start ; i<i_end ; i++) { |
||
| 777 | b = drs->GetBoard(i); |
||
| 778 | if (atoi(param[1]) == 1) { |
||
| 779 | b->SetDominoActive(1); |
||
| 780 | puts("Domino wave active during readout"); |
||
| 781 | } else { |
||
| 782 | b->SetDominoMode(0); |
||
| 783 | puts("Domino wave stopped during readout"); |
||
| 784 | } |
||
| 785 | } |
||
| 786 | } |
||
| 787 | |||
| 788 | /* delayed start on/off ---------- */ |
||
| 789 | else if (match(param[0], "del")) { |
||
| 790 | for (i=i_start ; i<i_end ; i++) { |
||
| 791 | b = drs->GetBoard(i); |
||
| 792 | if (b->GetDRSType() == 4) |
||
| 793 | puts("Delayed start not possible for DRS4"); |
||
| 794 | else { |
||
| 795 | if (atoi(param[1]) == 1) { |
||
| 796 | b->SetDelayedStart(1); |
||
| 797 | puts("Delayed start is on"); |
||
| 798 | } else { |
||
| 799 | b->SetDelayedStart(0); |
||
| 800 | puts("Delayed start is off"); |
||
| 801 | } |
||
| 802 | } |
||
| 803 | } |
||
| 804 | } |
||
| 805 | |||
| 806 | /* transparent mode on/off ---------- */ |
||
| 807 | else if (match(param[0], "trans")) { |
||
| 808 | for (i=i_start ; i<i_end ; i++) { |
||
| 809 | b = drs->GetBoard(i); |
||
| 810 | if (b->GetDRSType() != 4) |
||
| 811 | puts("Transparen mode only possible for DRS4"); |
||
| 812 | else { |
||
| 813 | if (atoi(param[1]) == 1) { |
||
| 814 | b->SetTranspMode(1); |
||
| 815 | puts("Transparent mode is on"); |
||
| 816 | } else { |
||
| 817 | b->SetTranspMode(0); |
||
| 818 | puts("Transparent mode is off"); |
||
| 819 | } |
||
| 820 | } |
||
| 821 | } |
||
| 822 | } |
||
| 823 | |||
| 824 | /* standby mode on/off ---------- */ |
||
| 825 | else if (match(param[0], "standby")) { |
||
| 826 | for (i=i_start ; i<i_end ; i++) { |
||
| 827 | b = drs->GetBoard(i); |
||
| 828 | if (b->GetDRSType() != 4) |
||
| 829 | puts("Standby mode only possible for DRS4"); |
||
| 830 | else { |
||
| 831 | if (atoi(param[1]) == 1) { |
||
| 832 | b->SetStandbyMode(1); |
||
| 833 | puts("Standby mode is on"); |
||
| 834 | } else { |
||
| 835 | b->SetStandbyMode(0); |
||
| 836 | puts("Standby mode is off"); |
||
| 837 | } |
||
| 838 | } |
||
| 839 | } |
||
| 840 | } |
||
| 841 | |||
| 842 | /* offset ---------- */ |
||
| 843 | else if (match(param[0], "offset")) { |
||
| 844 | for (i=i_start ; i<i_end ; i++) { |
||
| 845 | b = drs->GetBoard(i); |
||
| 846 | b->SetVoltageOffset(atof(param[1]), atof(param[2])); |
||
| 847 | } |
||
| 848 | } |
||
| 849 | |||
| 850 | /* phase ---------- */ |
||
| 851 | else if (match(param[0], "phase")) { |
||
| 852 | for (i=i_start ; i<i_end ; i++) { |
||
| 853 | b = drs->GetBoard(i); |
||
| 854 | b->SetADCClkPhase(atoi(param[1]), atoi(param[2]) > 0); |
||
| 855 | } |
||
| 856 | } |
||
| 857 | |||
| 858 | /* directory ---------- */ |
||
| 859 | else if (match(param[0], "dir")) { |
||
| 860 | |||
| 861 | #ifdef HAVE_VME |
||
| 862 | #ifdef CF_VIA_USB |
||
| 863 | { |
||
| 864 | if (param[2][0]) |
||
| 865 | i = atoi(param[2]); |
||
| 866 | else |
||
| 867 | i = 1; |
||
| 868 | printf("Physical drive %d:\n", i); |
||
| 869 | |||
| 870 | if (ace_init(NULL, i, &ace) != ACE_SUCCESS) { |
||
| 871 | printf("Cannot access ACE on physical drive %d\n", i); |
||
| 872 | } else { |
||
| 873 | #else |
||
| 874 | for (i=i_start ; i<i_end ; i++) { |
||
| 875 | |||
| 876 | /* do only once per VME board */ |
||
| 877 | if (i_end - i_start > 1 && (i % 2) == 1) |
||
| 878 | continue; |
||
| 879 | |||
| 880 | b = drs->GetBoard(i); |
||
| 881 | |||
| 882 | printf("VME slot %2d: ", (b->GetSlotNumber() >> 1) + 2); |
||
| 883 | |||
| 884 | if (ace_init(b->GetVMEInterface(), (b->GetSlotNumber() >> 1)+2, &ace) != ACE_SUCCESS) { |
||
| 885 | printf("Cannot access ACE in slot %d\n", (b->GetSlotNumber() >> 1)+2); |
||
| 886 | } else { |
||
| 887 | #endif |
||
| 888 | ace_dir(&ace); |
||
| 889 | } |
||
| 890 | } |
||
| 891 | #else |
||
| 892 | printf("No VME support compiled into drscl\n"); |
||
| 893 | #endif // HAVE_VME |
||
| 894 | } |
||
| 895 | |||
| 896 | /* upload ---------- */ |
||
| 897 | else if (match(param[0], "upload")) { |
||
| 898 | |||
| 899 | #ifdef HAVE_VME |
||
| 900 | #ifdef CF_VIA_USB |
||
| 901 | { |
||
| 902 | if (param[2][0]) |
||
| 903 | i = atoi(param[2]); |
||
| 904 | else |
||
| 905 | i = 1; |
||
| 906 | printf("Physical drive %d:\n", i); |
||
| 907 | |||
| 908 | if (ace_init(NULL, i, &ace) != ACE_SUCCESS) { |
||
| 909 | printf("Cannot access ACE on physical drive %d\n", i); |
||
| 910 | } else { |
||
| 911 | #else |
||
| 912 | |||
| 913 | /* use SVN file as default */ |
||
| 914 | if (param[1][0] == 0) { |
||
| 915 | #ifdef _MSC_VER |
||
| 916 | if (b->GetDRSType() == 4) |
||
| 917 | strcpy(str, "c:\\meg\\online\\VPC\\drs4\\2vp30\\cflash\\drs4\\rev0\\rev0.ace"); |
||
| 918 | else if (b->GetDRSType() == 3) |
||
| 919 | strcpy(str, "c:\\meg\\online\\VPC\\drs3\\2vp30\\cflash\\drs3\\rev0\\rev0.ace"); |
||
| 920 | else |
||
| 921 | strcpy(str, "c:\\meg\\online\\VPC\\drs2\\2vp30\\cflash\\drs2\\rev0\\rev0.ace"); |
||
| 922 | #else |
||
| 923 | if (b->GetDRSType() == 4) |
||
| 924 | strcpy(str, "/home/meg/meg/online/VPC/drs4/2vp30/cflash/drs4/rev0/rev0.ace"); |
||
| 925 | else if (b->GetDRSType() == 3) |
||
| 926 | strcpy(str, "/home/meg/meg/online/VPC/drs3/2vp30/cflash/drs3/rev0/rev0.ace"); |
||
| 927 | else |
||
| 928 | strcpy(str, "/home/meg/meg/online/VPC/drs2/2vp30/cflash/drs2/rev0/rev0.ace"); |
||
| 929 | #endif |
||
| 930 | printf("Enter filename or hit return for \n%s\n", str); |
||
| 931 | fgets(line, sizeof(line), stdin); |
||
| 932 | if (line[0] == '\r' || line[0] == '\n') |
||
| 933 | strcpy(file_name, str); |
||
| 934 | else |
||
| 935 | strcpy(file_name, line); |
||
| 936 | strcpy(param[1], str); |
||
| 937 | } else |
||
| 938 | strcpy(file_name, param[1]); |
||
| 939 | |||
| 940 | for (i=i_start ; i<i_end ; i++) { |
||
| 941 | |||
| 942 | /* do only once per VME board */ |
||
| 943 | if (i_end - i_start > 1 && (i % 2) == 1) |
||
| 944 | continue; |
||
| 945 | |||
| 946 | b = drs->GetBoard(i); |
||
| 947 | |||
| 948 | if (b->GetTransport() == TR_USB) { |
||
| 949 | printf("Cannot upload to USB board.\n"); |
||
| 950 | } else { |
||
| 951 | printf("VME slot %d:\n", (b->GetSlotNumber() >> 1)+2); |
||
| 952 | if (ace_init(b->GetVMEInterface(), (b->GetSlotNumber() >> 1)+2, &ace) != ACE_SUCCESS) { |
||
| 953 | printf("Cannot access ACE in slot %d\n", (b->GetSlotNumber() >> 1)+2); |
||
| 954 | } else { |
||
| 955 | #endif |
||
| 956 | status = ace_upload(&ace, file_name); |
||
| 957 | } |
||
| 958 | } |
||
| 959 | } |
||
| 960 | printf("\nPlease issue a power cycle to activate new firmware\n"); |
||
| 961 | #else |
||
| 962 | printf("No VME support compiled into drscl\n"); |
||
| 963 | #endif // HAVE_VME |
||
| 964 | } |
||
| 965 | |||
| 966 | /* download ---------- */ |
||
| 967 | else if (match(param[0], "download")) { |
||
| 968 | |||
| 969 | #ifdef HAVE_VME |
||
| 970 | b = drs->GetBoard(i_start); |
||
| 971 | |||
| 972 | if (b->GetTransport() == TR_USB) { |
||
| 973 | printf("Cannot upload to USB board.\n"); |
||
| 974 | } else { |
||
| 975 | printf("VME slot %d:\n", (b->GetSlotNumber() >> 1)+2); |
||
| 976 | if (ace_init(b->GetVMEInterface(), (b->GetSlotNumber() >> 1)+2, &ace) != ACE_SUCCESS) { |
||
| 977 | printf("Cannot access ACE in slot %d\n", (b->GetSlotNumber() >> 1)+2); |
||
| 978 | } else { |
||
| 979 | strcpy(str, "rev0.ace"); |
||
| 980 | if (param[1][0] == 0) { |
||
| 981 | printf("Enter filename or hit return for \n%s\n", str); |
||
| 982 | fgets(line, sizeof(line), stdin); |
||
| 983 | if (line[0] == '\r' || line[0] == '\n') |
||
| 984 | strcpy(file_name, str); |
||
| 985 | else |
||
| 986 | strcpy(file_name, line); |
||
| 987 | strcpy(param[1], str); |
||
| 988 | } else |
||
| 989 | strcpy(file_name, param[1]); |
||
| 990 | |||
| 991 | if (strchr(file_name, '\r')) |
||
| 992 | *strchr(file_name, '\r') = 0; |
||
| 993 | if (strchr(file_name, '\n')) |
||
| 994 | *strchr(file_name, '\n') = 0; |
||
| 995 | |||
| 996 | status = ace_download(&ace, file_name); |
||
| 997 | } |
||
| 998 | } |
||
| 999 | #else |
||
| 1000 | printf("No VME support compiled into drscl\n"); |
||
| 1001 | #endif // HAVE_VME |
||
| 1002 | } |
||
| 1003 | |||
| 1004 | /* calibration ---------- */ |
||
| 1005 | else if (match(param[0], "calib")) { |
||
| 1006 | debug = strcmp(param[1], "debug") == 0 || strcmp(param[2], "debug") == 0 || strcmp(param[3], "debug") == 0; |
||
| 1007 | if (param[1][0]) { |
||
| 1008 | strlcpy(dir, param[1], sizeof(str)); |
||
| 1009 | } else |
||
| 1010 | getcwd(dir, sizeof(dir)); |
||
| 1011 | |||
| 1012 | while (dir[strlen(dir)-1] == '\n' || dir[strlen(dir)-1] == '\r') |
||
| 1013 | dir[strlen(dir)-1] = 0; |
||
| 1014 | |||
| 1015 | b = drs->GetBoard(i_start); |
||
| 1016 | |||
| 1017 | printf("\n Enter calibration frequency [GHz]: "); |
||
| 1018 | fgets(line, sizeof(line), stdin); |
||
| 1019 | freq = atof(line); |
||
| 1020 | |||
| 1021 | if (b->GetDRSType() == 2) { |
||
| 1022 | printf(" Enter the expected trigger frequency [Hz]: "); |
||
| 1023 | fgets(line, sizeof(line), stdin); |
||
| 1024 | triggerfreq = atof(line); |
||
| 1025 | } else |
||
| 1026 | triggerfreq = 0; |
||
| 1027 | |||
| 1028 | ext_refclk = 0; |
||
| 1029 | if (b->GetBoardType() == 6) { |
||
| 1030 | printf("Use [e]xternal or [i]nternal reference clock: "); |
||
| 1031 | fgets(line, sizeof(line), stdin); |
||
| 1032 | ext_refclk = line[0] == 'e'; |
||
| 1033 | } |
||
| 1034 | |||
| 1035 | if (b->GetDRSType() == 4) { |
||
| 1036 | printf(" Enter range [V]: "); |
||
| 1037 | fgets(line, sizeof(line), stdin); |
||
| 1038 | range = atof(line); |
||
| 1039 | |||
| 1040 | printf(" Enter mode [1]024 or [2]048 bin mode: "); |
||
| 1041 | fgets(line, sizeof(line), stdin); |
||
| 1042 | cascading = atoi(line); |
||
| 1043 | } else { |
||
| 1044 | range = 0; |
||
| 1045 | cascading = 0; |
||
| 1046 | } |
||
| 1047 | |||
| 1048 | if (b->GetDRSType() == 4) { |
||
| 1049 | printf("\nPlease make sure that no input signal are present then hit any key\r"); |
||
| 1050 | fflush(stdout); |
||
| 1051 | while (!drs_kbhit()); |
||
| 1052 | printf(" \r"); |
||
| 1053 | while (drs_kbhit()) |
||
| 1054 | getchar(); |
||
| 1055 | } |
||
| 1056 | |||
| 1057 | for (i=i_start ; i<i_end ; i++) { |
||
| 1058 | b = drs->GetBoard(i); |
||
| 1059 | if (b->GetTransport() == TR_VME) |
||
| 1060 | printf("Creating Calibration of Board in VME slot %2d %s, serial #%04d\n", |
||
| 1061 | (b->GetSlotNumber() >> 1)+2, ((b->GetSlotNumber() & 1) == 0) ? "upper" : "lower", |
||
| 1062 | b->GetBoardSerialNumber()); |
||
| 1063 | else |
||
| 1064 | printf("Creating Calibration of Board on USB, serial #%04d\n", |
||
| 1065 | b->GetBoardSerialNumber()); |
||
| 1066 | if (b->GetDRSType() == 4) { |
||
| 1067 | ProgressBar p; |
||
| 1068 | if (b->GetTransport() == TR_VME) { |
||
| 1069 | if (cascading == 2) |
||
| 1070 | b->SetChannelConfig(7, 8, 4); // 7 means read all 9 channels per chip |
||
| 1071 | else |
||
| 1072 | b->SetChannelConfig(7, 8, 8); |
||
| 1073 | } else { |
||
| 1074 | if (cascading == 2) |
||
| 1075 | b->SetChannelConfig(0, 8, 4); |
||
| 1076 | else |
||
| 1077 | b->SetChannelConfig(0, 8, 8); |
||
| 1078 | } |
||
| 1079 | |||
| 1080 | b->SetRefclk(ext_refclk); |
||
| 1081 | b->SetFrequency(freq, true); |
||
| 1082 | b->SetInputRange(range); |
||
| 1083 | b->CalibrateVolt(&p); |
||
| 1084 | } else { |
||
| 1085 | b->SetDebug(debug); |
||
| 1086 | b->Init(); |
||
| 1087 | b->SetFrequency(freq, true); |
||
| 1088 | b->SoftTrigger(); |
||
| 1089 | |||
| 1090 | if (b->GetDRSType() == 3) |
||
| 1091 | b->GetResponseCalibration()->SetCalibrationParameters(1,11,0,20,0,0,0,0,0); |
||
| 1092 | else |
||
| 1093 | b->GetResponseCalibration()->SetCalibrationParameters(1,36,110,20,19,40,15,triggerfreq,0); |
||
| 1094 | if (!strcmp(dir,"lab")) |
||
| 1095 | b->SetCalibrationDirectory("C:/experiment/calibrations"); |
||
| 1096 | else if (!strcmp(dir,"area")) |
||
| 1097 | b->SetCalibrationDirectory("/home/meg/meg/online/calibrations"); |
||
| 1098 | else |
||
| 1099 | b->SetCalibrationDirectory(dir); |
||
| 1100 | for (j=0;j<2;j++) { |
||
| 1101 | b->GetResponseCalibration()->ResetCalibration(); |
||
| 1102 | while (!b->GetResponseCalibration()->RecordCalibrationPoints(j)) {} |
||
| 1103 | while (!b->GetResponseCalibration()->FitCalibrationPoints(j)) {} |
||
| 1104 | while (!b->GetResponseCalibration()->OffsetCalibration(j)) {} |
||
| 1105 | if (!b->GetResponseCalibration()->WriteCalibration(j)) |
||
| 1106 | break; |
||
| 1107 | } |
||
| 1108 | } |
||
| 1109 | } |
||
| 1110 | } |
||
| 1111 | |||
| 1112 | /* timing calibration ---------- */ |
||
| 1113 | else if (match(param[0], "tcalib")) { |
||
| 1114 | |||
| 1115 | freq = 0; |
||
| 1116 | if (param[1][0]) |
||
| 1117 | freq = atof(param[1]); |
||
| 1118 | |||
| 1119 | if (freq == 0) { |
||
| 1120 | printf("Enter calibration frequency [GHz]: "); |
||
| 1121 | fgets(line, sizeof(line), stdin); |
||
| 1122 | freq = atof(line); |
||
| 1123 | } |
||
| 1124 | |||
| 1125 | for (i=i_start ; i<i_end ; i++) { |
||
| 1126 | b = drs->GetBoard(i); |
||
| 1127 | if (b->GetDRSType() < 4) |
||
| 1128 | printf("Timing calibration not possivle for DRS2 or DRS3\n"); |
||
| 1129 | else if (b->GetFirmwareVersion() < 13279) |
||
| 1130 | printf("Firmware revision 13279 or later required for timing calibration\n"); |
||
| 1131 | else if (b->GetDRSType() == 4) { |
||
| 1132 | printf("Creating Timing Calibration of Board #%d\n", b->GetBoardSerialNumber()); |
||
| 1133 | ProgressBar p; |
||
| 1134 | b->SetFrequency(freq, true); |
||
| 1135 | status = b->CalibrateTiming(&p); |
||
| 1136 | if (!status) |
||
| 1137 | printf("Error performing timing calibration, please check waveforms\n"); |
||
| 1138 | printf("\n"); |
||
| 1139 | } |
||
| 1140 | } |
||
| 1141 | } |
||
| 1142 | |||
| 1143 | /* tcout ---------- */ |
||
| 1144 | else if (match(param[0], "tcout")) { |
||
| 1145 | float time[1024]; |
||
| 1146 | int chip; |
||
| 1147 | int k; |
||
| 1148 | int idx = 0; |
||
| 1149 | int first_board = i_start; |
||
| 1150 | int last_board = i_end; |
||
| 1151 | |||
| 1152 | file_name[0] = 0; |
||
| 1153 | strcpy(file_name, param[1]); |
||
| 1154 | if (file_name[0]) { |
||
| 1155 | f = fopen(file_name, "wt"); |
||
| 1156 | if (f == NULL) { |
||
| 1157 | printf("Cannot open file \"%s\"\n", file_name); |
||
| 1158 | } else { |
||
| 1159 | first_board = 0; |
||
| 1160 | last_board = drs->GetNumberOfBoards(); |
||
| 1161 | } |
||
| 1162 | idx += atoi(param[2]); |
||
| 1163 | } else |
||
| 1164 | f = NULL; |
||
| 1165 | |||
| 1166 | if (f) { |
||
| 1167 | fprintf(f, "-- Replace %%%% with correct id\n"); |
||
| 1168 | } |
||
| 1169 | for (i=first_board ; i<last_board ; i++) { |
||
| 1170 | b = drs->GetBoard(i); |
||
| 1171 | if (b->GetDRSType() >= 4) { |
||
| 1172 | for (chip = 0; chip < b->GetNumberOfChips(); chip++) { |
||
| 1173 | b->GetTime(chip, 0, b->GetTriggerCell(0), time, true, false); |
||
| 1174 | if (f) { |
||
| 1175 | fprintf(f, "INSERT INTO MEGDRSTimeCalibration VALUES(%%%%,%d,%d", idx, |
||
| 1176 | static_cast<int>(b->GetNominalFrequency() * 10 + 0.5) * 100); |
||
| 1177 | for (j=0 ; j<1024 ; j++) |
||
| 1178 | fprintf(f, ",%g", time[j] * 1e-9); |
||
| 1179 | fprintf(f, ",%d,%d", b->GetBoardSerialNumber(), chip); |
||
| 1180 | fprintf(f, ",%g);\n", 1 / (b->GetNominalFrequency() * 1e9) * 1024); |
||
| 1181 | idx++; |
||
| 1182 | } else { |
||
| 1183 | printf("Board %d\n", b->GetBoardSerialNumber()); |
||
| 1184 | for (j=0 ; j<128 ; j++) { |
||
| 1185 | printf("%4d: ", j*8); |
||
| 1186 | for (k=0 ; k<7 ; k++) |
||
| 1187 | printf("%6.1lf ", time[j*8+k]); |
||
| 1188 | printf("%6.1lf\n", time[j*8+k]); |
||
| 1189 | } |
||
| 1190 | printf("n"); |
||
| 1191 | } |
||
| 1192 | } |
||
| 1193 | } else { |
||
| 1194 | // DRS2 or DRS3 |
||
| 1195 | idx += 2; |
||
| 1196 | } |
||
| 1197 | } |
||
| 1198 | if (f) { |
||
| 1199 | fclose(f); |
||
| 1200 | printf("Data successfully written to \"%s\"\n", file_name); |
||
| 1201 | } |
||
| 1202 | } |
||
| 1203 | |||
| 1204 | /* read */ |
||
| 1205 | else if (match(param[0], "read")) { |
||
| 1206 | float waveform[2048]; |
||
| 1207 | short swaveform[2048]; |
||
| 1208 | calib = 0; |
||
| 1209 | |||
| 1210 | file_name[0] = 0; |
||
| 1211 | if (param[1][0]) { |
||
| 1212 | idx = atoi(param[1]); |
||
| 1213 | calib = atoi(param[2]); |
||
| 1214 | if (strlen(param[2]) > 2) |
||
| 1215 | strcpy(file_name, param[2]); |
||
| 1216 | else |
||
| 1217 | strcpy(file_name, param[3]); |
||
| 1218 | } else { |
||
| 1219 | printf("Enter channel number (0..19): "); |
||
| 1220 | fgets(line, sizeof(line), stdin); |
||
| 1221 | idx = atoi(line); |
||
| 1222 | } |
||
| 1223 | |||
| 1224 | if (idx<0 || idx>19) |
||
| 1225 | printf("Channel number must be between 0 and 19\n"); |
||
| 1226 | else { |
||
| 1227 | b = drs->GetBoard(i_start); |
||
| 1228 | if (!b->IsEventAvailable()) |
||
| 1229 | printf("Error: Domino wave is running, please issue a \"stop\" first\n"); |
||
| 1230 | else { |
||
| 1231 | if (calib == 1) { |
||
| 1232 | if (b->GetDRSType() == 4) { |
||
| 1233 | if (!b->IsVoltageCalibrationValid()) { |
||
| 1234 | printf("Calibration not valid for board #%d\n", b->GetBoardSerialNumber()); |
||
| 1235 | calib = 0; |
||
| 1236 | } |
||
| 1237 | |||
| 1238 | } else { |
||
| 1239 | #ifdef _MSC_VER |
||
| 1240 | b->SetCalibrationDirectory("C:/experiment/calibrations"); |
||
| 1241 | #else |
||
| 1242 | b->SetCalibrationDirectory("/home/meg/meg/online/calibrations"); |
||
| 1243 | #endif |
||
| 1244 | if (!b->GetResponseCalibration()->IsRead(0)) |
||
| 1245 | if (!b->GetResponseCalibration()->ReadCalibration(0)) |
||
| 1246 | calib = 0; |
||
| 1247 | if (!b->GetResponseCalibration()->IsRead(1)) |
||
| 1248 | if (!b->GetResponseCalibration()->ReadCalibration(1)) |
||
| 1249 | calib = 0; |
||
| 1250 | } |
||
| 1251 | } |
||
| 1252 | |||
| 1253 | status = b->TransferWaves(idx, idx); |
||
| 1254 | if (file_name[0]) { |
||
| 1255 | f = fopen(file_name, "wt"); |
||
| 1256 | if (f == NULL) |
||
| 1257 | printf("Cannot open file \"%s\"\n", file_name); |
||
| 1258 | } else |
||
| 1259 | f = NULL; |
||
| 1260 | |||
| 1261 | if (calib) { |
||
| 1262 | status = b->GetWave(idx/b->GetNumberOfChannels(), idx%b->GetNumberOfChannels(), waveform, |
||
| 1263 | true, b->GetTriggerCell(idx/b->GetNumberOfChannels()), b->GetStopWSR(idx/b->GetNumberOfChannels())); |
||
| 1264 | if (status == 0) { |
||
| 1265 | if (f) |
||
| 1266 | for (i=0 ; i<b->GetChannelDepth() ; i++) |
||
| 1267 | fprintf(f, "%6.1lf\n", waveform[i]); |
||
| 1268 | else { |
||
| 1269 | for (i=0 ; i<b->GetChannelDepth()/8 ; i++) { |
||
| 1270 | printf("%4d: ", i*8); |
||
| 1271 | for (j=0 ; j<7 ; j++) |
||
| 1272 | printf("%6.1lf ", waveform[i*8+j]); |
||
| 1273 | printf("%6.1lf\n", waveform[i*8+j]); |
||
| 1274 | } |
||
| 1275 | } |
||
| 1276 | } |
||
| 1277 | } else { |
||
| 1278 | status = b->GetWave(idx/b->GetNumberOfChannels(), idx%b->GetNumberOfChannels(), swaveform, 0, 0); |
||
| 1279 | if (status == 0) { |
||
| 1280 | if (f) |
||
| 1281 | for (i=0 ; i<b->GetChannelDepth() ; i++) |
||
| 1282 | fprintf(f, "%4d\n", swaveform[i]); |
||
| 1283 | else { |
||
| 1284 | for (i=0 ; i<b->GetChannelDepth()/16 ; i++) { |
||
| 1285 | for (j=0 ; j<15 ; j++) |
||
| 1286 | printf("%4d ", swaveform[i*16+j] >> 4); |
||
| 1287 | printf("%4d\n", swaveform[i*16+j] >> 4); |
||
| 1288 | } |
||
| 1289 | } |
||
| 1290 | } |
||
| 1291 | } |
||
| 1292 | } |
||
| 1293 | } |
||
| 1294 | |||
| 1295 | if (f) { |
||
| 1296 | fclose(f); |
||
| 1297 | printf("Data successfully written to \"%s\"\n", file_name); |
||
| 1298 | } |
||
| 1299 | } |
||
| 1300 | |||
| 1301 | /* register test ---------- */ |
||
| 1302 | else if (match(param[0], "reg")) { |
||
| 1303 | b->RegisterTest(); |
||
| 1304 | } |
||
| 1305 | |||
| 1306 | /* RAM test */ |
||
| 1307 | else if (match(param[0], "ram")) { |
||
| 1308 | if (param[1][0] == 0) |
||
| 1309 | b->RAMTest(3); |
||
| 1310 | else |
||
| 1311 | b->RAMTest(atoi(param[1])); |
||
| 1312 | } |
||
| 1313 | |||
| 1314 | /* Change input range */ |
||
| 1315 | else if (match(param[0], "range")) { |
||
| 1316 | for (i=i_start ; i<i_end ; i++) { |
||
| 1317 | b = drs->GetBoard(i); |
||
| 1318 | if (param[1][0] == 0) { |
||
| 1319 | printf("Input range: "); |
||
| 1320 | fgets(str, sizeof(str), stdin); |
||
| 1321 | } else |
||
| 1322 | strlcpy(str, param[1], sizeof(str)); |
||
| 1323 | |||
| 1324 | b->SetInputRange(atof(str)); |
||
| 1325 | printf("Range set to %1.2lg V ... %1.2lg V\n", atof(str)-0.5, atof(str)+0.5); |
||
| 1326 | } |
||
| 1327 | } |
||
| 1328 | |||
| 1329 | /* Chip Test */ |
||
| 1330 | else if (match(param[0], "ct")) { |
||
| 1331 | if (drs->GetNumberOfBoards() == 0) |
||
| 1332 | puts("No DRS board found"); |
||
| 1333 | else { |
||
| 1334 | puts("Press 'q' to quit, any other key to repeat test.\n"); |
||
| 1335 | do { |
||
| 1336 | if (b->ChipTest()) |
||
| 1337 | puts("Chip test successfully finished"); |
||
| 1338 | else |
||
| 1339 | puts("\007Chip Error!"); |
||
| 1340 | |||
| 1341 | b->SetStandbyMode(1); |
||
| 1342 | for (i=0 ; i<8 ; i++) |
||
| 1343 | b->SetDAC(i, 0); |
||
| 1344 | i = getch(); |
||
| 1345 | b->SetStandbyMode(0); |
||
| 1346 | } while (i != 'q'); |
||
| 1347 | } |
||
| 1348 | } |
||
| 1349 | |||
| 1350 | /* calib0 for speed vs. temperature calibration */ |
||
| 1351 | else if (match(param[0], "c0")) { |
||
| 1352 | |||
| 1353 | double volt, freq; |
||
| 1354 | |||
| 1355 | b->Init(); |
||
| 1356 | b->SetFrequency(5, true); |
||
| 1357 | b->EnableAcal(0, 0); |
||
| 1358 | b->SetDominoMode(1); |
||
| 1359 | |||
| 1360 | for (volt=2.5 ; volt > 0 ; volt -= 0.05) { |
||
| 1361 | printf("%4.1lf - %5.3lf ", b->GetTemperature(), volt); |
||
| 1362 | b->SetDAC(1, volt); |
||
| 1363 | b->SetDAC(2, volt); |
||
| 1364 | Sleep(100); |
||
| 1365 | b->ReadFrequency(0, &freq); |
||
| 1366 | |||
| 1367 | printf("%5.3lf\n", freq); |
||
| 1368 | |||
| 1369 | if (drs_kbhit()) |
||
| 1370 | break; |
||
| 1371 | } |
||
| 1372 | |||
| 1373 | while (drs_kbhit()) |
||
| 1374 | getch(); |
||
| 1375 | |||
| 1376 | b->Init(); // reset voltage offset |
||
| 1377 | } |
||
| 1378 | |||
| 1379 | /* calib1 */ |
||
| 1380 | else if (match(param[0], "c1")) { |
||
| 1381 | |||
| 1382 | short swaveform[1024]; |
||
| 1383 | double volt; |
||
| 1384 | double av[1024]; |
||
| 1385 | int k; |
||
| 1386 | |||
| 1387 | b->Init(); |
||
| 1388 | b->SetFrequency(5, true); |
||
| 1389 | b->SetDominoMode(1); |
||
| 1390 | b->SetDominoActive(1); |
||
| 1391 | b->SetReadoutMode(1); |
||
| 1392 | |||
| 1393 | for (volt=-0.5 ; volt <= 0.5001 ; volt += 0.02) { |
||
| 1394 | printf("%4.1lf - %6.0lf ", b->GetTemperature(), 1000*volt); |
||
| 1395 | b->EnableAcal(1, volt); |
||
| 1396 | b->StartDomino(); |
||
| 1397 | Sleep(100); |
||
| 1398 | |||
| 1399 | memset(av, 0, sizeof(av)); |
||
| 1400 | |||
| 1401 | for (j=0 ; j<100 ; j++) { |
||
| 1402 | for (i=0 ; i<10 ; i++) |
||
| 1403 | b->IsBusy(); |
||
| 1404 | b->SoftTrigger(); |
||
| 1405 | while (b->IsBusy()); |
||
| 1406 | b->StartDomino(); |
||
| 1407 | b->TransferWaves(b->GetNumberOfChannels()*b->GetNumberOfChips()); |
||
| 1408 | i = b->GetTriggerCell(0); |
||
| 1409 | b->GetWave(0, 0, swaveform, false, i, 1); |
||
| 1410 | |||
| 1411 | for (k=0 ; k<1024 ; k++) |
||
| 1412 | av[k] += swaveform[k]; |
||
| 1413 | |||
| 1414 | if (drs_kbhit()) |
||
| 1415 | break; |
||
| 1416 | } |
||
| 1417 | |||
| 1418 | for (k=0 ; k<1024 ; k++) |
||
| 1419 | av[k] /= j; |
||
| 1420 | |||
| 1421 | for (k=0 ; k<5 ; k++) |
||
| 1422 | printf("%10.2lf ", 1000*(av[k]/65536-0.5)); |
||
| 1423 | printf("\n"); |
||
| 1424 | |||
| 1425 | if (drs_kbhit()) |
||
| 1426 | break; |
||
| 1427 | } |
||
| 1428 | // keep chip "warm" |
||
| 1429 | b->StartDomino(); |
||
| 1430 | } |
||
| 1431 | |||
| 1432 | /* test0 */ |
||
| 1433 | else if (match(param[0], "t0")) { |
||
| 1434 | b->Init(); |
||
| 1435 | b->SetDominoMode(1); |
||
| 1436 | b->SetDominoActive(1); |
||
| 1437 | b->SetReadoutMode(1); |
||
| 1438 | b->SetFrequency(0.8, true); |
||
| 1439 | b->EnableTrigger(1, 0); |
||
| 1440 | b->SetTriggerLevel(1); |
||
| 1441 | b->SetChannelConfig(0, 8, 4); |
||
| 1442 | |||
| 1443 | do { |
||
| 1444 | b->StartDomino(); |
||
| 1445 | while (b->IsBusy()) |
||
| 1446 | if (drs_kbhit()) |
||
| 1447 | break; |
||
| 1448 | |||
| 1449 | b->TransferWaves(); |
||
| 1450 | |||
| 1451 | if (b->GetBoardType() == 5) { |
||
| 1452 | printf("%04d(0x%03X) - %3d\n", b->GetTriggerCell(0), b->GetTriggerCell(0), |
||
| 1453 | b->GetStopWSR(0)); |
||
| 1454 | } else { |
||
| 1455 | printf("%04d %04d %04d %04d - %3d %3d %3d\n", |
||
| 1456 | b->GetTriggerCell(0), |
||
| 1457 | b->GetTriggerCell(1), |
||
| 1458 | b->GetTriggerCell(2), |
||
| 1459 | b->GetTriggerCell(3), |
||
| 1460 | b->GetTriggerCell(1)-b->GetTriggerCell(0), |
||
| 1461 | b->GetTriggerCell(2)-b->GetTriggerCell(0), |
||
| 1462 | b->GetTriggerCell(3)-b->GetTriggerCell(0)); |
||
| 1463 | } |
||
| 1464 | Sleep(300); |
||
| 1465 | } while (!drs_kbhit()); |
||
| 1466 | |||
| 1467 | while (drs_kbhit()) |
||
| 1468 | getch(); |
||
| 1469 | } |
||
| 1470 | |||
| 1471 | /* test1 simple start/stop loop */ |
||
| 1472 | else if (match(param[0], "t1")) { |
||
| 1473 | time_t t1, t2; |
||
| 1474 | |||
| 1475 | b->SetDebug(1); |
||
| 1476 | b->Init(); |
||
| 1477 | b->SetFrequency(5, true); |
||
| 1478 | b->SetDominoMode(1); |
||
| 1479 | b->SetReadoutMode(0); |
||
| 1480 | b->SetTranspMode(0); |
||
| 1481 | b->SetDominoActive(1); |
||
| 1482 | b->EnableAcal(1, 0.5); |
||
| 1483 | b->EnableTcal(1); |
||
| 1484 | time(&t1); |
||
| 1485 | do { |
||
| 1486 | time(&t2); |
||
| 1487 | } while (t1 == t2); |
||
| 1488 | i=0; |
||
| 1489 | t1 = t2; |
||
| 1490 | do { |
||
| 1491 | b->StartDomino(); |
||
| 1492 | b->SoftTrigger(); |
||
| 1493 | b->TransferWaves(); |
||
| 1494 | i++; |
||
| 1495 | time(&t2); |
||
| 1496 | if (t2 > t1) { |
||
| 1497 | printf("%d events/sec\n", i); |
||
| 1498 | i = 0; |
||
| 1499 | t1 = t2; |
||
| 1500 | } |
||
| 1501 | } while (!drs_kbhit()); |
||
| 1502 | |||
| 1503 | while (drs_kbhit()) |
||
| 1504 | getch(); |
||
| 1505 | } |
||
| 1506 | |||
| 1507 | /* test2 readout from stop position */ |
||
| 1508 | else if (match(param[0], "t2")) { |
||
| 1509 | short sw[1024]; |
||
| 1510 | double volt = 0.5; |
||
| 1511 | |||
| 1512 | b->Init(); |
||
| 1513 | b->SetNumberOfChannels(10); |
||
| 1514 | b->SetChannelConfig(0, 9, 12); |
||
| 1515 | b->SetFrequency(2, true); |
||
| 1516 | b->EnableTcal(1); |
||
| 1517 | b->SetReadoutMode(0); |
||
| 1518 | b->SetDominoActive(0); |
||
| 1519 | b->SetDominoMode(1); |
||
| 1520 | b->SetCalibTiming(0, 0); |
||
| 1521 | b->StartDomino(); |
||
| 1522 | b->EnableAcal(1, 0.5); |
||
| 1523 | if (!b->GetResponseCalibration()->IsRead(0)) |
||
| 1524 | if (!b->GetResponseCalibration()->ReadCalibration(0)) |
||
| 1525 | printf("cannot read calibration\n"); |
||
| 1526 | |||
| 1527 | do { |
||
| 1528 | //volt += 0.25; |
||
| 1529 | if (volt > 1) |
||
| 1530 | volt = 0; |
||
| 1531 | b->SoftTrigger(); |
||
| 1532 | while (b->IsBusy()); |
||
| 1533 | b->StartDomino(); |
||
| 1534 | b->EnableAcal(1, volt); |
||
| 1535 | b->TransferWaves(); |
||
| 1536 | |||
| 1537 | b->GetWave(0, 1, sw, 0, 0); |
||
| 1538 | printf("%d ", sw[100]); |
||
| 1539 | b->GetWave(0, 1, sw, 1, 0); |
||
| 1540 | printf("%1.4lf\n", sw[100]/4096.0); |
||
| 1541 | } while (!drs_kbhit()); |
||
| 1542 | while (drs_kbhit()) getch(); |
||
| 1543 | } |
||
| 1544 | |||
| 1545 | /* DAC Loop */ |
||
| 1546 | else if (match(param[0], "t3")) { |
||
| 1547 | double volt; |
||
| 1548 | do { |
||
| 1549 | for (volt=2.5 ; volt > 0 ; volt -= 0.05) { |
||
| 1550 | |||
| 1551 | printf("%4.1lf - %5.3lf\n", b->GetTemperature(), volt); |
||
| 1552 | b->SetDAC(0, volt); |
||
| 1553 | b->SetDAC(1, 2.5-volt); |
||
| 1554 | Sleep(100); |
||
| 1555 | if (drs_kbhit()) |
||
| 1556 | break; |
||
| 1557 | } |
||
| 1558 | } while (!drs_kbhit()); |
||
| 1559 | |||
| 1560 | while (drs_kbhit()) |
||
| 1561 | getch(); |
||
| 1562 | } |
||
| 1563 | |||
| 1564 | /* noise measurement */ |
||
| 1565 | else if (match(param[0], "t4")) { |
||
| 1566 | int i, n; |
||
| 1567 | short sw[1024]; |
||
| 1568 | double ofs[1024], sx, sxx, avg, stdev, enob; |
||
| 1569 | |||
| 1570 | b->Init(); |
||
| 1571 | b->SetFrequency(2, true); |
||
| 1572 | b->EnableTcal(0); |
||
| 1573 | b->SetDominoMode(1); |
||
| 1574 | b->StartDomino(); |
||
| 1575 | b->EnableAcal(1, 0.5); |
||
| 1576 | Sleep(100); |
||
| 1577 | b->SoftTrigger(); |
||
| 1578 | while (b->IsBusy()); |
||
| 1579 | b->StartDomino(); |
||
| 1580 | Sleep(100); |
||
| 1581 | memset(ofs, 0, sizeof(ofs)); |
||
| 1582 | |||
| 1583 | for (i=0 ; i<10 ; i++) { |
||
| 1584 | b->SoftTrigger(); |
||
| 1585 | while (b->IsBusy()); |
||
| 1586 | b->StartDomino(); |
||
| 1587 | b->TransferWaves(1); |
||
| 1588 | b->GetWave(0, 0, sw, 0, 0); |
||
| 1589 | sx = sxx = 0; |
||
| 1590 | for (n=0 ; n<1024 ; n++) { |
||
| 1591 | ofs[n] += sw[n]; |
||
| 1592 | } |
||
| 1593 | } |
||
| 1594 | |||
| 1595 | for (n=0 ; n<1024 ; n++) |
||
| 1596 | ofs[n] /= i; |
||
| 1597 | |||
| 1598 | for (i=0 ; i<10 ; i++) { |
||
| 1599 | b->SoftTrigger(); |
||
| 1600 | while (b->IsBusy()); |
||
| 1601 | b->StartDomino(); |
||
| 1602 | b->TransferWaves(1); |
||
| 1603 | b->GetWave(0, 0, sw, 0, 0); |
||
| 1604 | |||
| 1605 | sx = sxx = 0; |
||
| 1606 | for (n=10 ; n<1014 ; n++) { |
||
| 1607 | sx += (sw[n]-ofs[n])/4096.0; |
||
| 1608 | sxx += (sw[n]-ofs[n])/4096.0*(sw[n]-ofs[n])/4096.0; |
||
| 1609 | } |
||
| 1610 | |||
| 1611 | if (i>5) |
||
| 1612 | Sleep(5000); |
||
| 1613 | |||
| 1614 | avg = sx / n; |
||
| 1615 | stdev = sqrt((sxx-sx*sx/n)/(n-1)); |
||
| 1616 | enob = log(1/stdev)/log(2.); |
||
| 1617 | printf("avg=%1.4lf sd=%1.4lf ENOB=%1.1lf\n", avg, stdev, enob); |
||
| 1618 | }; |
||
| 1619 | } |
||
| 1620 | |||
| 1621 | /* exit/quit ---------- */ |
||
| 1622 | else if (match(param[0], "exit") || match(param[0], "quit")) |
||
| 1623 | break; |
||
| 1624 | |||
| 1625 | else { |
||
| 1626 | if (strchr(param[0], '\r')) |
||
| 1627 | *strchr(param[0], '\r') = 0; |
||
| 1628 | if (strchr(param[0], '\n')) |
||
| 1629 | *strchr(param[0], '\n') = 0; |
||
| 1630 | printf("Unknon command \"%s\"\n", param[0]); |
||
| 1631 | } |
||
| 1632 | |||
| 1633 | } while (1); |
||
| 1634 | |||
| 1635 | delete drs; |
||
| 1636 | } |
||
| 1637 | |||
| 1638 | /*------------------------------------------------------------------*/ |
||
| 1639 | |||
| 1640 | int main() |
||
| 1641 | { |
||
| 1642 | printf("DRS command line tool, Revision %d\n", atoi(drscl_svn_revision+15)); |
||
| 1643 | printf("Type 'help' for a list of available commands.\n\n"); |
||
| 1644 | |||
| 1645 | cmd_loop(); |
||
| 1646 | return 1; |
||
| 1647 | } |