mirror of
https://github.com/slsdetectorgroup/slsDetectorPackage.git
synced 2026-02-02 06:04:55 +01:00
9.0.0.rc (#1058)
* dev: update 2d gain plot color map (if no x and ymin/max changes or window resizing): setFixedWidth was updating for window resize, updated virtual servers for g2 and jungfrau to keep changing gain and data for every frame. the data value (#819) * Dev/jf/fix pedestal (#821) * jf pedestal fix: touch enable bit last * dev: jf sync: stopping master gives idle (#824) * jf sync mode master could return idle when stopped and so not all modules return the same value and must check for 'stopped or idle', Also must throw if any of the module gives an error * added contains_only to sls::Result (#827) * added variadic template for checking if a result contains only specified values * fix for gcc4.8 * renamed to Result::contains_only * updated condition in Detector.cpp * stop on only the positions --------- Co-authored-by: Erik Fröjdh <erik.frojdh@gmail.com> * dev jf: change status reg bits (#829) * jf: rewrite of status reg bits, waiting state includes both wati for trigger and start frame, blocking trigger only waits if its not in waiting for trigger and run busy enabled, error state connected in firmware * dev jf: reconfigure chip when touching electron collection mode bit (#831) * jf: if bit 14 in reg 0x5d (electron mode collection bit) is changed, configure chip if v1.1 and powered on. so touch writeregister (setbit/clearbit also calls write register in the end). replace when electroncollectionmode command introduced * eiger required fw version to 32: fix for blocking trigger in quad (#834) * fix warning for prev_val (variable size array) in tests (#838) * Dev: : gui acq finished callback for different status (#850) * fix acquisition finished status to have different status for different modules, but does not have to be error. for eg. jf sync fw (2.4.1 gives idle for master and stopped for slaves when stopping acquiistion) * handling inconsistent fnums to be -1 in gui, so when one sets 0 (change of value) will also give an exception (#854) * Dev: fix py virtual test (#846) * draft to fix virtual test when it fails * catching errors in tests and removing sigchild ignore so servers (process in background) executing commands will not fail (pclose no child processes, if sigchld is ignored) fixed * uncommented python loading config * somehow killal slsReciever in second detector test fails even though no receiver running * fixing script for virtual simlator test:fixed issue with check if process running, fixed moench tests * formatting * tests for jf (#835) * execute command inside server fixed (from fix simulator tests and exec command PR) (#857) * dev: fix server logic in checking detector idle (#861) * fix buggy logic in checking detector idle and an argument check * Dev: trigger signal issues handled at acquire (#864) * if blocking and handling sync, only master gets blocking acq, slaves get non blocking as they are first and so dont get status or error caught when slaves dont get trigger (due to not connected etc) and acq returns with slaves still in waiting status. so check status of all in blocking acq * for all dets with sync, ensure atleast one master when starting acq * docs updated about sync * minor fix for test_simulator * updating docs * fixed doc * added python 3.12 to the conda build variants * documentation and examples * formatting * forward declare zmq_msg_t and moved include (#869) * forward declare zmq_msg_t and moved include * removed zmq from pkg list * removed zmq as dependency for slsdet (#870) * dev: moench: min exptime (#865) * moench: remove min clock cycles for setting exptime (had been ported from jf) * commands code generation (#871) * commands code generation (#803) * commands code generation for only frames command * fix cmake file and add Caller files * working exptime, fully extended commands file and its variants * start adding template commands * add INT_CMD_VEC_ID template * add list command, generate multiple bins, format code * reach 208 commands using the cpp macros * add tests for command parser * start adding tests for commands parser * fix typo to use commands.yaml * add more tests for command_parser * add all template functions (up to 218 commands) * finish template functions and add more CmdProxy.cpp functions (250+) * 257 commands * 300 commands the rest are very special commands * add special commands without generation * separate special functions from generated c++ file * implementing one command for put and get (buggy) * add infer action in a separate file * generate header for special commands from yaml * allow only 0 or 1 for bool inputs * group all commands in gen_commands.py * add help to gen_commands.py * add autocomplete bash script * autocompletion: add support for module levels and help * remove debugging line * add autocompletion, help to commands, change int [0,1] to bool * copy tests for Caller.cpp. Tests pass * update with the new developer branch changes * fix errors after merging (there is problems with tests) * fixed port/stopport in yaml (intput typo), added '_caller' to the test dac and test on chip dac command in global test for cmdcaller * undo previous test simulator debug change * add documentation for the generated code * reducing the comment to be replaced in length so formatting does not split into 2 lines * removed formatting specific style of C++11 in gen_commands.py to keep with the top level clang format of the project * regeneratign code for commands * automation generated * Redirect deprecated commands (#872) * working implementation, need to fix dac * fixed deprecation redirect for dac command * Detector specific autocomplete (#873) * working implementation, need to fix dac * fixed deprecation redirect for dac command * detector specific completion for dac * added autocomplete using detector specific * fixed error when autocompleting partial words * Generate commands/fix commands (#875) * fix vm_a, im_a etc have deg Celsius suffix, also help missing or changed in some places * dac: require det id for all, arg0 to be printed at output, help for onchip dac and dac, onchipdac: spacing * getscan detid and blocking trigger help * udp_Dstlist det_id fixed, but rx_id invalid * cmdApp in line with cmdLineApp (missing version, receiver_id, not creating det object in help action * added set_command to differentiate between check_det_id and require_det_id (mixed up), args: -1 needs to check for at least one argument * reordering * reordering and checked till integer_command_hex * fixed a lot more commands * fix caller tests for eiger * changes to tests after Bechir left * changing .cmd to .cmdcall for the caller commands * fixed tests for caller, still warning for setexptime about cast input * autocomplete ran * add moench test * regenerating autocomplete and commands * fixing other things from merge conflicts (renaming slsDetectorDefs to defs in commands.yaml) * formatting * added code injection to help (#876) * updated 3 commands to have get output that can be put into put (#877) * updated some commands to have get output that can be put into put * fix tests for clkdiv * adding help to free (#878) * removing old commands and renaming them, (also making it work for parameters command as it was still calling cmdproxy) (#879) * More helpful error messages for unsupported actions (#880) * removing old commands and renaming them, (also making it work for parameters command as it was still calling cmdproxy) * Added specific help for unsupported actions * fixed a vetofile get special exception message. more specific warning for special exception message instead of no function warning * added condition checking true in exceptions for special message --------- Co-authored-by: Bechir Brahem <bachbrahem@gmail.com> Co-authored-by: Erik Frojdh <erik.frojdh@gmail.com> Co-authored-by: Dhanya Thattil <dhanya.thattil@psi.ch> * Generate commands/fix det command rename (#881) * made a link to bash autocompletion script in main folder, and replaced all references to 'det' command with 'sls_detector' * Generate commands/fix detp detg command rename (#882) * replacing detp with sls_Detector_put and detg with sls_detector_get * sls_detector_not implemented, but extended message to ask user to use sls_detector_get or sls_detector_put * autocompletion also for sls_detector or det * Xilinx ctb (#884) * updated registers, arm64 * compiler set to aarch64 for xilinx server * updated RegisterDefs.h * merge into generate branch and resolving conflicts and adding the xilinx changes to callerspecial and commands.yaml * compiles and can print firmware version (using a different csp0 address) * fixing other servers (gotthard, jungfrau, moench, mythen3) that it returns in case of mapping failure, xilinxctb: added that it checks type, prints proper fw version, checks kernel date, added armprocessor define to use in common places, added specifiers to supress overflow and truncation warnings * added detector ip and mac adddress to the printout * fixed tests and recompiled servers * Xilinx client tests (#887) * implemented testbus, testfpga, set/get #frames, triggers, allowed that and for connection to client, also allowed, getnumchannels, configuremac, getrunstatus, setdetectorposition with dummy values * allowing tests for xilinx * binaries in * Dev/xilinx defaults and pattern (#888) * implemented testbus, testfpga, set/get #frames, triggers, allowed that and for connection to client, also allowed, getnumchannels, configuremac, getrunstatus, setdetectorposition with dummy values * connected kernelversion, hardwareversion, versions, framesl, triggersl, dr, timingmode, pattern (except patioctrl) thats there for altera ctb * replaced set/get64Bit to set/getU64bit in all loadpattern.c for (ctb and m3 also) * minor * updated commands generation * formatting * moench default speed set to after init readout configuration (half speed) (#886) * Fixed path when building as submodule * Moench v8 (#892) * new rct structure for moench03 * new moench data structure for offline processing * meonch raw data and zmq process files updated to 7.0.3 version * implemented config file for Zmq file * raw data and zmq work with config file, but only with one file/interface * zmq config change * added config examples for zmq and rawdata * pmod for 7.0.3 and 8.0.0 from previous releases * updated pmod 8.0.1 for rh7 and rh8 * m3 fix to get kernel version properly on nios without an incorrect error msg (#898) * moench: changed max shifts of adc clk from 240 to 200 (#900) * Protect from getenv("HOME") returning nullptr (#907) (#908) * Protect from getenv("HOME") returning nullptr (e.g., in case running in systemd) * Write proper warning in Module.cpp Co-authored-by: Filip Leonarski <filip.leonarski@psi.ch> * Dev/xilinx acq (#901) * period and exptime(patternwaittime level 0) * added new regsieterdefs and updated api version and fixedpattern reg * autogenerate commands * formatting * minor * wip resetflow, readout mode, transceiver mask, transceiver enable * acquisition, but streaming done bit and busy (exposing + read chip to fifo) not known yet from fw * programming fpga and device tree done * most configuration done, need to connect configuretransceiver to client * stuck at resetting transciever timed out * minor * fixed virtual, added chip busyto fifo, streaming busy, set/getnext framenumber * configuretransceiver from client, added help in client * make formatt and command generation * tests for xilinx ctb works * command generation * dacs added and tested, power not done * power added * added temp_fpga * binaries in * ctrlreg is 0 to enable chip=fixed, high dac val = min val= fixed, power regulators in weird order=fixed, device tree could be loaded with dacs before adcs=fixed * start works * virtual server sends * receiver works * tests * python function and enum generation, commands generatorn and autocomplete, formatting, tests * tests fail at start(transceiver not aligned) * tests passed * all binaries compiled * eiger binary in * added --nomodule cehck for xilinx * updated binaries * formatting * moench server: changed default values of adcphase for full speed from 300 to 150 and dac vipre_cds from 800 to 1280 (#922) * client bug fix: m3 multi module bad channel file throws bad allocation when modules skipped, needed to add vectors in 2d vector of bad channel list (#920) Co-authored-by: Erik Fröjdh <erik.frojdh@gmail.com> * developer: blocking acquire stop with slave temporarily in waiting (#926) * client: stopping a blocking acquire of multi modules checks status to catch slaves that might still be in waiting. Problem is (gotthard2 25um at least) slave is in waiting only temporarily before going go idle/stopped. So a 50ms sleep is necessary ot not throw an unnecessary error * client: when stopping blocking acquire, wait up to 1s in 50ms increments for slave to stop waiting temporarily * fix to rapidjson for build with gcc 14 (#929) * Dev: m3 clkdiv0 20 (#924) * m3: clk 0 changed from 10 to 20 (100MHz to 50MHz) * g2: startup clk div back to 10 as in firmware but setting in software startup to 20 * m3: minor print error if clk divider > max * G2: reconfigure chip (#927) * changed common.c readADCFromFile to make it more general and move temperature calculation for Eiger out of this function and inside whereever it is called. * g2 and m2: gethighvoltage was just a variable set in server, it is now moved to a get inside DAC5671 implementation (but not reading a measured value, instead what is set from a file), high voltage variable used inside DAC5671 for virtual servers * g2: switching off hv (ifrom non zero to zero value) will wait for 10s; powering on chip reconfigures chip; powering off chip unconfigures chip; powering off chip also includes check if hv = 0, if not throw exception; chip configuration checked before acquring; at start up: hv switched off and chip powered on, so does not wait 10s to switch off hv; * included test to check powering off chip when hv is on should throw an exception * g2: check if chip configured before acquiring * nios: read hv value set from file and virtual still goes into DAC5671 for conversions to and fro dac to V, change common readadc to readparameter to generalize, make sethighvoltage into a get and set to catch errors in get as well, g2: if not at startup, remmeber hv value before setting it and after check if value was being switched off (from a non zero value) and wait 10s if it was (10s wait only for switching off from non zero and not at startup) * developer: moench empty data callback (#936) * moench (feature to wait for post processing to be done in new sls_detector_acquire_zmq executable) READOUT_ACTION_ZMQ added to action enums sls_detector_acquire_zmq added to executables empty data call back so that client listens to last dummy zmq packet from moench post processor processor: remove NEWZMQ ifdefs and remove connect for zmq publisher socket * fix to compile * cmds generated and parsed * dev: client: status for blocking acquire stop with slave temporarily in waiting (#944) * acq finish call back gets status squashed with default error but before that need to wait for gotthard slaves to catch up from waiting to stopped * bug fixes related to file saving (#931) (#946) * fix the file path resetting issue of GUI in the case where different modules have different fpath setting. * fix stack-buffer-overflow issue when using HDF5 HDF5DataFile::parameterDataTypes have 64bit type (i.e. STD_U64LE), the size of fill_value should be at least 8 bytes. * change the type of fill_value to uint64_t Co-authored-by: Z.H. Li <zhenghenge@gmail.com> * updated documentation from martin (#948) * Dev/xilinx ctb test (#942) * voltage regulators only looks at dac and not at ctrl_reg * xilinx: change dac max to 2048, setting dac ist not inverse conversion from dac to voltage anymore, but setting power is inverse, also there is max and min to power, a different min for vio and this is checked at funcs interface, not printign or converting to mv in dac for power regulators (as its conversion max and min are different) * Use links for dacs/adc and adapt power rglt thresholds * Remove wait for transceiver reset * adc and dac device not used anymore and hence removed * udp restucturing: arm has to be multiple of 16 and no byteswap in udp_gen, option to compile locally in arm architecture, memsize of the second udp memory has to be limited --------- Co-authored-by: Martin Brückner <martin.brueckner@psi.ch> * formatting * dev: jungfrau HW 1.0: adc output clock phase to 120 (#952) * jungfrau: change adc output clock phase from 180 to 120 for v1.0 boards for reliable readout of adc #2 * versioning * formatting * rx: moved creating fpath (if it doesnt exist) from setting file path to at the start of acquisition when creating file. This is done here so that it does not fail if fwrite is disabled anyway. Also fixed it in documentation. Changed in documentation that the default for fwrite is disabled (#957) * added keepalive zmq socket option (after 60s of idle time, 10 probes every sec. Mainly because an issue at Max IV (#956) * Moench mess from developer (#953) * new moench data structure for offline processing * Dev/zmq stream all ipv6 adn remove rx_zmqip (#958) * enable ipv6 in zmq socket * removed rx_zmqip API and field in gui, changed client updaterxrzip to updateclientzmqip to have the rx_hostname ip if 0. * updated command line for rx_zmqip to give a warning. * Replaced 'depreciated' to 'deprecated' everywhere * switching from * to 0.0.0.0 works for rebinding zmq sockets * fixed help in command line for rx_zmqip * to 0.0.0.0 and removed cmd in python * remove publisher zmq socket ip also for moench post processing * fixed tests * publisher zmq ip macros to be reused * fixed a warning about narrowing conversion from size_t to int (#963) * fixed stop server not starting up with setup variables (#949) * m3: fixed stop server not starting up with setup variables * all servers except eiger fixed for virtual stop server to start up with setupDetector function called * virtual tests work * eiger: versions print neednt be in stop server * jungfrau: stop server (not virtual) also needs to read config file * ensuring master is setup for virtual and real servers * Dev/pyctbgui merge (#960) * added empty c extension * added rotation to the decoding * added color map, options and findex * minor * move checks to before acquisition * added pixel map based decoder * cleanup * no thread creation for single thread processing * added rotation and test to compare * allow high and low water mark for zmq (also buffer size) for fast readouts * removed roatation during decoding * added Transpose to image and invert Y False to invert it * retains the zoomed state after the first image of gui, catch and display exception if no detector connected * moved start frame to dockable widget, removed extra frame number label, moved current measurement also to dockable widget, hide frame plot entirely when showing patternviewer * first image dependin on which plot * remember settings of main window size and position, dockewidget if docked, its size and posisiotn as well, then update it next time the gui is opened * change in comment * using c decoder for moench 04 and matterhorn * catch exception from invalid image from decoder * clean up * update row and col when choosing image type, neeeded to show values * fix for previous PR * disable resetting colormap values keep the range selected for every new acquisition * fix typos + tested on virtual matterhorn * minor print * refactored Slow ADCs Tab * refactored DAC tab * refactored power supplies * refactored signals tab * refactored transceiver tab * fix typo * fix typo2 * remove commented code * delete commented code * delete commented code * delete commented signals code * remove commented code for transceiver tab * refactor adc tab * refactor Pattern Tab * Refactor transceivers tab (PR#5) (#118) * refactored transceiver tab * remove commented code for transceiver tab --------- Co-authored-by: Erik Frojdh <erik.frojdh@gmail.com> * refactor adc tab (PR#6) (#119) * refactor adc tab * refactored Plot and Acquisition Tabs * fix the regression issue * restructure project files * applying singleton and renaming tabs to services * working install using pip * applies singleton to tab classes and remove CI erros * added pyzmq and pillow * remove the singleton implementation and keep changes * fix merge errors in mainWindow * moved misplaced init file * rename service to tab * reorganize imports * iterate over tabs * reorder tabs * add slowadc to the list * saving changes (buggy) power supply ui not showing in the gui * split power supply tab * fixed tests * add hardcoded values to defines file * fix error * separate power supply * fix errors for powerSuppliesTab * split dacs * split slow adcs * split signals tab * added tests for bit_utils * add slowAdc class to defines * split transceiver ui file * split adc.ui * split pattern ui file * split plot and acquisition ui file * added basic test for parsing bit names * removed redundant code in read_alias_file * fix dacs ui position * testing for correct exception * cmd and args at split * group radio buttons * fix comments from PR#1 * show legend * added python version and dev requirements to setup.py * fix dac issue * moved _decoder into pkg * added inplace build * removed clear * fixed dependencies * make tests run without slsdet * updated name of action * define colcount * fixed loading of alias file * add yapf and ruff * apply formatting * fix E and F rules * add more ruff rules * change variable name * squashing gh debugging commits and add pre-commit * update label values to mv units * add hook for yapf * reconfigure yapf precommit hook * add format and check_format to makefile * change gh actions * update readme * added check_format * WIP * added linting in github action * updated readme] * add more control for color choice * remove useless file * fix un-updated line after refactoring Defines BIT0_31_MASK is not found in Defines.signals * visually improve the interface * fix last commit * add only selected plots for legend * add hide legend button * change hide legend to show legend checkbox show legend is checked by default * add support for saving in numpy * solve conversations * fix acq index offset * fix browse button in pattern error * fix other browse button errors * finish tests and add usage.md * remove buffer * add file,numpy-like interface and tests * remove useless .npy files * subscriptible npz files * remove useless files * remove repetetive tests * save changes * add mode r+, add with support,remove logging * remove offset of acqIndex between raw and numpy saving * fix only saving last frame * save signals of multiple devices * add comments and move condition for clearer code * fix bug when vieweing pattern file * iterate over enabled and plotted plots * add padestal substraction to transceiver and analog data * init pedestal frames to detector.frames * restore old exception * add pedestal substraction for digital signals * remove frames spinbox from plotTab * remove comments and use str instead of Path * avoid saving all frames * correct exception and log error's trace * add gui tests * add waveform test * add pedestal test * refactor by using fixtures * add tests for moench analog and pattern * add pytest-qt to dependencies * add save and load gui parameters * remove nohup file * fix old bug IndexError * save plot type * a * handle canceling load, loading matterhorn pedestal for moench * remove comparing .png files for pattern test * save plot type * red error on status bar when shape mismatch for loaded pedestal * fix makefile and docstrings * fix PRs conversation * move code into different function * fix wrong function names for power supply * removed old ctbgui * removed unnecessary files --------- Co-authored-by: Erik Frojdh <erik.frojdh@gmail.com> Co-authored-by: Braham Bechir <braham_b@pc11979.psi.ch> Co-authored-by: Bechir <bechir.braham@psi.ch> Co-authored-by: Bechir <bechir.brahem420@gmail.com> * Dev/xilinx mat update (#959) * put back code to obtain adc and dac device indexafter loading device tree and then create folder iio_device_links and create symbolic links there according to device indices found. ln -sf operation not permitted, so folder has to be deleted and created everytime. Also refactored definitions to have all the xilinx name or detector specific stuff out of programbyArm.c * uncommented waittransceiverreset at startup (should work now) and return of powering off chip at startup (error for transceiver alignment reset) * updated registerdefs from firmware * minor prints and updating names from registerdefs * waittransceiverreset has been fixed in firmware and removing warnign for that, transceiver alignment check for powering off chip is not done in fw (giving a warning and returning ok for now) * fixing ipchecksum (not done), removed startperiphery, allowing readout command to be allowed for xilinx when acquiring * dont build doc for Tobi Schluter from libzmq, which uses iso-8859-1 and the umlaut cause compilation to fail on some machines (#973) * 8.0.2 psi modules * missed the rx_zmqip implementations in detector.h and python bindings (#975) * rx_zmqip has been removed. Remove it also for pyctbgui (#979) * format * Dev/rx callbacks (#966) * changed rxr callback signatures to all include structs * removed datamodify call back as size can be changed in the original data call back now * bringing some parameters (set functions) to dataProcessor class for its callback (namely udpport, quad, fliprows, totalframes, jsonheader), resulting in also removing totalframes from 2 other function signatures * updated MultiReceiverApp to reflect the new callback signatures * Dev/reg bit change no validate (#970) - do not validate write reg, setbit and clearbit by default anymore - --validate will force validation on the bitmask or entire reg - remove return value for write reg (across server to client, but thankfully not in the Detector class) - extend validation into writereg, setbit and clearbit for Eiger (always special) - need to check python (TODO) - missed the rx_zmqip implementations in detector.h and python bindings * sleep implemented for command line, mainly for config files for firmware developers (#982) * change gain mode help from dynamicgain to dynamic (#988) * fixing python version. allowing versions to execute even if no detector connected or in shared memory (#990) * Jf: Electron collection mode (#983) * electron collection mode for jungfrau. also removing the config chip when using register command * collectionMode: HOLE/ELECTRON (enum) * Dev/m3 readout speed (#985) * added readoutspeed command to m3 (fullspeed - 10, half speed - 20, quarter speed - 40), removed reaodut pll, moved up system pll clock indices, leaving pll index in common altera code, default speed is half speed, allow only system_c0 to be set, the others can be obtained, same for clkphase, maxclkphaseshift, clkfreq. added to readoutspeedlist commands, updated help and updated tests * updated readoutspeedlist command * jf: timing info decoder (#987) * timing_info_decoder command with options swissfel (default) and shine. added to python, command line generation, autocomplete, tostring, tests. * updated jungfrau timing info decoder mask (#991) * minor. removed warning print at startup for empty eth udp to listen to (#992) * removed 'Caller/CALLER' from test names as there is only one command line now (#993) * formatting * Dev/g2 stop frame number (#980) * get/set next frame number in G2 (firmware only has set, no get) * firmware has issues: each stop keeps 2 frame header in fifo and the resetting frame number happens after that * removed the option to set burstmode to burst external or continuwous internal * needs to be revisited before 9.0.0 * formatting * fix the command help in the command help generator for Gotthard2 about nextframenumber (#994) * first draft at fixing nextframenumber properly with firmware (#995) * fixing nextframenumber properly with firmware * updated firmware to have getnextframenumber and fixed setnextframenumber to reset also the header fifo when stopping * fix tests for gotthard2 * Dev/g2 fix next frame number (#996) * binaries in * formatting * release notes * release notes * updating firmware dates * release notes * package release version and renaming server names * updated client versioning * updated moench fw release version * 900/proper free (#1002) * first draft of fixing the free function available within the class * removed class member function freeSharedmemory for both Detector and Module; made the free function freeSharedmemory accessible to python interface; setHostname if there is already a module in shm will recreate the Detector object while freeing shm completely and keeping detsize and intitialchecks (previous commit), sethostname called from DetectorClass in virtual command to have one point of entry (previous commit), testing Module class frees shared memory using free function * Detector class: added copy and move constructor and assignmentoperators due to explicit destructor (DetectorImpl fwd declared), DetectorImpl class: included ZmqSocket to remove destructor (should not be virtual in any case), Module class: removed explciit destructor to allow compiler generated constructor and operators * formatting * updated client version date * minor fix for readme autocomplete * setting detsize after hostname should throw also for single module for consistency (#999) * 900/autocomplete documentation (#1003) * fixed the gendoc to reflect the new parser, updated documentation to include info about autocomplete in the command line part, error in createing docs * fixed list deprecated, fixed command help (to show properly on a html, fixed other help warnings * minor indents * 900/g2 chip configure at startup (#1008) * g2: chip reconfigure variable not set when powering on at startup because readconfig is the one configuring the chip the first time to default chip settings * cleaning up code * 900/rm volatile (#1006) * Removing volatile and replacing with atomic to ensure atomicity * compiling header include issue * 900/jf firmware rollback (#1010) * jf: rolling back firmware required to v1.5 and 2.5, updated release notes, fixed a bug when updating server (when server name same as link name:throws with no message, pedestal mode check changed for the time being for loops to be 0xFF size * compensating for jf fw bug for pedestalmode where loops should be 16 bit, but is 8 bit in fw. to be fixed in next version * formatting * fixed python test simulator to kill previous servers * gui: hide 'complete image' and just show 'missing packets' when there are missing packets in that image form the receiver (#1013) * release notes update (#1015) * 900/detach pthreads not joining (#1017) * detach the pthreads that are not joining else memory leak * release notes * removed the clean up comment, also refactored the pthread join/detach for ctb 1g * 900/server malloc check (#1020) * usleep in communication to actually relay the err message of memory allocation to the client (weird but test for now), function in server to handle memory allcoation issues (updates mess, ret and sendsit to the client and returns prior from function implementatin, setting fnum in client for the speicific functions that send to detector each argument separtely, they need to remember the fnum else they throw with the incorrect fnum * server: every malloc must check if it succeeded, rearranging so that the free is clear as well (only in funcs so far) * formatting * fixed malloc checks in other places other than funcs.c * bug fix return from previous commit * pointer bug from previous commit * formatting * binaries in * 900/document json ctb file format (#1027) * docs receiver formats rewrite * added documentation for all the receiver files, updated release notes, udpated help in commands help for timing, fixed by throwing exception for aa dividy by 0 error caused by not freeing memory (detsize) when switching between 1d and 2d detectors, removed unnecessary 'recevier up' printout, fixed dbit list 64 bit mask error in master json file (was not 64 bit before), fixed bug in reading gotthard1 data (needs to be tested) * generating commands help and formatting, also fix help for trimen command line * added ctb frame format documentation, added some links to some commands, added documentation about adding expat-devel in installation for rhel8 gui, fixed some indentation issues that screwed up command line help documentation * added ctb frame format documentation * updated documentation about zeromq-devel for <8.0.0 versions * fixed typo in python for vb_pixbuf Jungfrau dac (#1030) * fixed cli documentation (#1037) * 900: legal gain values in jungfrau simulator (#1043) * legal gain values in jungfrau simulator * typo * release notes * 900/jungfrau temp control default enable (#1041) * jungfrau: enabling temp control by default at server startup * 900: fixed invalid arguments to slsmultireceiver (#1039) * wasnt showing error message for invalid arguments to slsmultireceiver * allow 0 arguments to act like an slsReceiver with start tcp port 1954 and just 1 receiver * 9.0.0: version from file to cmake and python (#1024) - renamed conda-recipe folder - added a check to see if build and install folder exists in build.sh (conda recipe) - created VERSION file that has '0.0.0'for developer but can be updated using update_version.py that takes in a version. The script checks for semantic versioning and updates VERSION file - VERSION file also copied along with py files to slsdet in python cmakelist and build_pylib.sh (for conda), also copied in root folder for installations (for no coding purpose) - init.py and setup.py reads this file to get the version (a bit differently to find the VERSION file) - VERSION file read into cmake to get the version and also added to compile definition. So RELEASE removed from versionAPI.h (using SLS_DET_VERSION compile definiton instead) and also removed updateRelease script. - conda getting project version from environment variable SLS_DET_VERSION that is set in build_pylib.sh prior. - added 3.13 python to conda build - anything related to ctb removed from release notes as users will always use developer - sets 9.0.0 to VERSION file by running update_version.py without an argument * formatting * finalized binaries * updated m3 fw version (#1046) * release notes * fix cmake (cannot find VERSION file) when using package as subfolder as cmake_source_dir is not same anymore, add troubleshooting doc for m3 regarding loose control board for waiting status in auto timing mode, fix m3 tests to test register write (previously was read only) (#1047) * 900: bumped pybind11 version and added setuptools on host (#1050) * bumped pybind11 version and added setuptools on host * updated pybind11 tarball to 2.13 and in cmakefile to get 2.13 frpm github, also updated documentation about pybind 2.13 * update release notes, doc * updating readme --------- Co-authored-by: Erik Fröjdh <erik.frojdh@gmail.com> * 900 cmake_source_dir (#1053) * when package used as subdirectory (cmake-subfolder-example) it fails when python is used because the cmake_source_dir is now the one above package. * changed cmake_current_list_dir to cmake_current_source_dir * removing the unnecessary VERSION file installed in the root directory (from PR #1020) * 900: pybind 2.13.6 and python 3.8 (#1054) * changed pybind 2.13.0 to 2.13.6, kept conda at min 2.13.0 * changed min python version from 3.6 to 3.8 * 900/docs (#1056) * minimum python is 3.8, so >= * removed ctb frame documentation. should be in internal wiki * updated release notes * updated releate date --------- Co-authored-by: Erik Fröjdh <erik.frojdh@gmail.com> Co-authored-by: froejdh_e <erik.frojdh@psi.ch> Co-authored-by: anberga <34126852+anberga@users.noreply.github.com> Co-authored-by: Filip Leonarski <filip.leonarski@psi.ch> Co-authored-by: Z.H. Li <zhenghenge@gmail.com> Co-authored-by: Martin Brückner <martin.brueckner@psi.ch> Co-authored-by: Braham Bechir <braham_b@pc11979.psi.ch> Co-authored-by: Bechir <bechir.braham@psi.ch> Co-authored-by: Bechir <bechir.brahem420@gmail.com>
This commit is contained in:
GitHub
18214
slsDetectorSoftware/src/Caller.cpp
Normal file
18214
slsDetectorSoftware/src/Caller.cpp
Normal file
File diff suppressed because it is too large
Load Diff
890
slsDetectorSoftware/src/Caller.h
Normal file
890
slsDetectorSoftware/src/Caller.h
Normal file
@@ -0,0 +1,890 @@
|
||||
// This file is used as input to generate the caller class
|
||||
|
||||
#include "CmdParser.h"
|
||||
#include "HelpDacs.h"
|
||||
#include "sls/Detector.h"
|
||||
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
namespace sls {
|
||||
|
||||
class Caller {
|
||||
public:
|
||||
Caller(Detector *ptr) : det(ptr) {}
|
||||
void call(const std::string &command,
|
||||
const std::vector<std::string> &arguments, int detector_id,
|
||||
int action, std::ostream &os = std::cout, int receiver_id = -1);
|
||||
|
||||
IpAddr getDstIpFromAuto();
|
||||
IpAddr getSrcIpFromAuto();
|
||||
UdpDestination getUdpEntry();
|
||||
void GetLevelAndUpdateArgIndex(int action,
|
||||
std::string levelSeparatedCommand,
|
||||
int &level, int &iArg, size_t nGetArgs,
|
||||
size_t nPutArgs);
|
||||
void WrongNumberOfParameters(size_t expected);
|
||||
|
||||
template <typename V> std::string OutStringHex(const V &value) {
|
||||
if (value.equal())
|
||||
return ToStringHex(value.front());
|
||||
return ToStringHex(value);
|
||||
}
|
||||
|
||||
template <typename V> std::string OutStringHex(const V &value, int width) {
|
||||
if (value.equal())
|
||||
return ToStringHex(value.front(), width);
|
||||
return ToStringHex(value, width);
|
||||
}
|
||||
|
||||
template <typename V> std::string OutString(const Result<V> &value) {
|
||||
if (value.equal())
|
||||
return ToString(value.front());
|
||||
return ToString(value);
|
||||
}
|
||||
|
||||
template <typename V> std::string OutString(const V &value) {
|
||||
return ToString(value);
|
||||
}
|
||||
|
||||
template <typename V>
|
||||
std::string OutString(const V &value, const std::string &unit) {
|
||||
if (value.equal())
|
||||
return ToString(value.front(), unit);
|
||||
return ToString(value, unit);
|
||||
}
|
||||
|
||||
std::vector<std::string> getAllCommands();
|
||||
std::map<std::string, std::string> GetDeprecatedCommands();
|
||||
std::string list(int action);
|
||||
|
||||
std::string acquire(int action);
|
||||
std::string activate(int action);
|
||||
std::string adcclk(int action);
|
||||
std::string adcenable(int action);
|
||||
std::string adcenable10g(int action);
|
||||
std::string adcindex(int action);
|
||||
std::string adcinvert(int action);
|
||||
std::string adclist(int action);
|
||||
std::string adcname(int action);
|
||||
std::string adcphase(int action);
|
||||
std::string adcpipeline(int action);
|
||||
std::string adcreg(int action);
|
||||
std::string adcvpp(int action);
|
||||
std::string apulse(int action);
|
||||
std::string asamples(int action);
|
||||
std::string autocompdisable(int action);
|
||||
std::string badchannels(int action);
|
||||
std::string blockingtrigger(int action);
|
||||
std::string burstmode(int action);
|
||||
std::string burstperiod(int action);
|
||||
std::string bursts(int action);
|
||||
std::string burstsl(int action);
|
||||
std::string bustest(int action);
|
||||
std::string cdsgain(int action);
|
||||
std::string chipversion(int action);
|
||||
std::string clearbit(int action);
|
||||
std::string clearbusy(int action);
|
||||
std::string clearroi(int action);
|
||||
std::string clientversion(int action);
|
||||
std::string clkdiv(int action);
|
||||
std::string clkfreq(int action);
|
||||
std::string clkphase(int action);
|
||||
std::string collectionmode(int action);
|
||||
std::string column(int action);
|
||||
std::string compdisabletime(int action);
|
||||
std::string confadc(int action);
|
||||
std::string config(int action);
|
||||
std::string configtransceiver(int action);
|
||||
std::string counters(int action);
|
||||
std::string currentsource(int action);
|
||||
std::string dac(int action);
|
||||
std::string dacindex(int action);
|
||||
std::string daclist(int action);
|
||||
std::string dacname(int action);
|
||||
std::string dacvalues(int action);
|
||||
std::string datastream(int action);
|
||||
std::string dbitclk(int action);
|
||||
std::string dbitphase(int action);
|
||||
std::string dbitpipeline(int action);
|
||||
std::string defaultdac(int action);
|
||||
std::string defaultpattern(int action);
|
||||
std::string delay(int action);
|
||||
std::string delayl(int action);
|
||||
std::string detectorserverversion(int action);
|
||||
std::string detsize(int action);
|
||||
std::string diodelay(int action);
|
||||
std::string dpulse(int action);
|
||||
std::string dr(int action);
|
||||
std::string drlist(int action);
|
||||
std::string dsamples(int action);
|
||||
std::string execcommand(int action);
|
||||
std::string exptime(int action);
|
||||
std::string exptime1(int action);
|
||||
std::string exptime2(int action);
|
||||
std::string exptime3(int action);
|
||||
std::string exptimel(int action);
|
||||
std::string extrastoragecells(int action);
|
||||
std::string extsampling(int action);
|
||||
std::string extsamplingsrc(int action);
|
||||
std::string extsig(int action);
|
||||
std::string fformat(int action);
|
||||
std::string filtercells(int action);
|
||||
std::string filterresistor(int action);
|
||||
std::string findex(int action);
|
||||
std::string firmwaretest(int action);
|
||||
std::string firmwareversion(int action);
|
||||
std::string fliprows(int action);
|
||||
std::string flowcontrol10g(int action);
|
||||
std::string fmaster(int action);
|
||||
std::string fname(int action);
|
||||
std::string foverwrite(int action);
|
||||
std::string fpath(int action);
|
||||
std::string framecounter(int action);
|
||||
std::string frames(int action);
|
||||
std::string framesl(int action);
|
||||
std::string frametime(int action);
|
||||
std::string free(int action);
|
||||
std::string fwrite(int action);
|
||||
std::string gaincaps(int action);
|
||||
std::string gainmode(int action);
|
||||
std::string gappixels(int action);
|
||||
std::string gatedelay(int action);
|
||||
std::string gatedelay1(int action);
|
||||
std::string gatedelay2(int action);
|
||||
std::string gatedelay3(int action);
|
||||
std::string gates(int action);
|
||||
std::string getbit(int action);
|
||||
std::string hardwareversion(int action);
|
||||
std::string highvoltage(int action);
|
||||
std::string hostname(int action);
|
||||
std::string im_a(int action);
|
||||
std::string im_b(int action);
|
||||
std::string im_c(int action);
|
||||
std::string im_d(int action);
|
||||
std::string im_io(int action);
|
||||
std::string imagetest(int action);
|
||||
std::string initialchecks(int action);
|
||||
std::string inj_ch(int action);
|
||||
std::string interpolation(int action);
|
||||
std::string interruptsubframe(int action);
|
||||
std::string kernelversion(int action);
|
||||
std::string lastclient(int action);
|
||||
std::string led(int action);
|
||||
std::string lock(int action);
|
||||
std::string master(int action);
|
||||
std::string maxadcphaseshift(int action);
|
||||
std::string maxclkphaseshift(int action);
|
||||
std::string maxdbitphaseshift(int action);
|
||||
std::string measuredperiod(int action);
|
||||
std::string measuredsubperiod(int action);
|
||||
std::string moduleid(int action);
|
||||
std::string nextframenumber(int action);
|
||||
std::string nmod(int action);
|
||||
std::string numinterfaces(int action);
|
||||
std::string overflow(int action);
|
||||
std::string packageversion(int action);
|
||||
std::string parallel(int action);
|
||||
std::string parameters(int action);
|
||||
std::string partialreset(int action);
|
||||
std::string patfname(int action);
|
||||
std::string patioctrl(int action);
|
||||
std::string patlimits(int action);
|
||||
std::string patloop(int action);
|
||||
std::string patloop0(int action);
|
||||
std::string patloop1(int action);
|
||||
std::string patloop2(int action);
|
||||
std::string patmask(int action);
|
||||
std::string patnloop(int action);
|
||||
std::string patnloop0(int action);
|
||||
std::string patnloop1(int action);
|
||||
std::string patnloop2(int action);
|
||||
std::string patsetbit(int action);
|
||||
std::string pattern(int action);
|
||||
std::string patternstart(int action);
|
||||
std::string patwait(int action);
|
||||
std::string patwait0(int action);
|
||||
std::string patwait1(int action);
|
||||
std::string patwait2(int action);
|
||||
std::string patwaittime(int action);
|
||||
std::string patwaittime0(int action);
|
||||
std::string patwaittime1(int action);
|
||||
std::string patwaittime2(int action);
|
||||
std::string patword(int action);
|
||||
std::string pedestalmode(int action);
|
||||
std::string period(int action);
|
||||
std::string periodl(int action);
|
||||
std::string polarity(int action);
|
||||
std::string port(int action);
|
||||
std::string powerchip(int action);
|
||||
std::string powerindex(int action);
|
||||
std::string powerlist(int action);
|
||||
std::string powername(int action);
|
||||
std::string powervalues(int action);
|
||||
std::string programfpga(int action);
|
||||
std::string pulse(int action);
|
||||
std::string pulsechip(int action);
|
||||
std::string pulsenmove(int action);
|
||||
std::string pumpprobe(int action);
|
||||
std::string quad(int action);
|
||||
std::string ratecorr(int action);
|
||||
std::string readnrows(int action);
|
||||
std::string readout(int action);
|
||||
std::string readoutspeed(int action);
|
||||
std::string readoutspeedlist(int action);
|
||||
std::string rebootcontroller(int action);
|
||||
std::string reg(int action);
|
||||
std::string resetdacs(int action);
|
||||
std::string resetfpga(int action);
|
||||
std::string roi(int action);
|
||||
std::string romode(int action);
|
||||
std::string row(int action);
|
||||
std::string runclk(int action);
|
||||
std::string runtime(int action);
|
||||
std::string rx_arping(int action);
|
||||
std::string rx_clearroi(int action);
|
||||
std::string rx_dbitlist(int action);
|
||||
std::string rx_dbitoffset(int action);
|
||||
std::string rx_discardpolicy(int action);
|
||||
std::string rx_fifodepth(int action);
|
||||
std::string rx_frameindex(int action);
|
||||
std::string rx_framescaught(int action);
|
||||
std::string rx_framesperfile(int action);
|
||||
std::string rx_hostname(int action);
|
||||
std::string rx_jsonaddheader(int action);
|
||||
std::string rx_jsonpara(int action);
|
||||
std::string rx_lastclient(int action);
|
||||
std::string rx_lock(int action);
|
||||
std::string rx_missingpackets(int action);
|
||||
std::string rx_padding(int action);
|
||||
std::string rx_printconfig(int action);
|
||||
std::string rx_realudpsocksize(int action);
|
||||
std::string rx_roi(int action);
|
||||
std::string rx_silent(int action);
|
||||
std::string rx_start(int action);
|
||||
std::string rx_status(int action);
|
||||
std::string rx_stop(int action);
|
||||
std::string rx_tcpport(int action);
|
||||
std::string rx_threads(int action);
|
||||
std::string rx_udpsocksize(int action);
|
||||
std::string rx_version(int action);
|
||||
std::string rx_zmqfreq(int action);
|
||||
std::string rx_zmqhwm(int action);
|
||||
std::string rx_zmqip(int action);
|
||||
std::string rx_zmqport(int action);
|
||||
std::string rx_zmqstartfnum(int action);
|
||||
std::string rx_zmqstream(int action);
|
||||
std::string samples(int action);
|
||||
std::string savepattern(int action);
|
||||
std::string scan(int action);
|
||||
std::string scanerrmsg(int action);
|
||||
std::string selinterface(int action);
|
||||
std::string serialnumber(int action);
|
||||
std::string setbit(int action);
|
||||
std::string settings(int action);
|
||||
std::string settingslist(int action);
|
||||
std::string settingspath(int action);
|
||||
std::string signalindex(int action);
|
||||
std::string signallist(int action);
|
||||
std::string signalname(int action);
|
||||
std::string sleep(int action);
|
||||
std::string slowadc(int action);
|
||||
std::string slowadcindex(int action);
|
||||
std::string slowadclist(int action);
|
||||
std::string slowadcname(int action);
|
||||
std::string slowadcvalues(int action);
|
||||
std::string start(int action);
|
||||
std::string status(int action);
|
||||
std::string stop(int action);
|
||||
std::string stopport(int action);
|
||||
std::string storagecell_delay(int action);
|
||||
std::string storagecell_start(int action);
|
||||
std::string subdeadtime(int action);
|
||||
std::string subexptime(int action);
|
||||
std::string sync(int action);
|
||||
std::string syncclk(int action);
|
||||
std::string temp_10ge(int action);
|
||||
std::string temp_adc(int action);
|
||||
std::string temp_control(int action);
|
||||
std::string temp_dcdc(int action);
|
||||
std::string temp_event(int action);
|
||||
std::string temp_fpga(int action);
|
||||
std::string temp_fpgaext(int action);
|
||||
std::string temp_fpgafl(int action);
|
||||
std::string temp_fpgafr(int action);
|
||||
std::string temp_slowadc(int action);
|
||||
std::string temp_sodl(int action);
|
||||
std::string temp_sodr(int action);
|
||||
std::string temp_threshold(int action);
|
||||
std::string templist(int action);
|
||||
std::string tempvalues(int action);
|
||||
std::string tengiga(int action);
|
||||
std::string threshold(int action);
|
||||
std::string timing(int action);
|
||||
std::string timing_info_decoder(int action);
|
||||
std::string timinglist(int action);
|
||||
std::string timingsource(int action);
|
||||
std::string top(int action);
|
||||
std::string transceiverenable(int action);
|
||||
std::string trigger(int action);
|
||||
std::string triggers(int action);
|
||||
std::string triggersl(int action);
|
||||
std::string trimbits(int action);
|
||||
std::string trimen(int action);
|
||||
std::string trimval(int action);
|
||||
std::string tsamples(int action);
|
||||
std::string txdelay(int action);
|
||||
std::string txdelay_frame(int action);
|
||||
std::string txdelay_left(int action);
|
||||
std::string txdelay_right(int action);
|
||||
std::string type(int action);
|
||||
std::string udp_cleardst(int action);
|
||||
std::string udp_dstip(int action);
|
||||
std::string udp_dstip2(int action);
|
||||
std::string udp_dstlist(int action);
|
||||
std::string udp_dstmac(int action);
|
||||
std::string udp_dstmac2(int action);
|
||||
std::string udp_dstport(int action);
|
||||
std::string udp_dstport2(int action);
|
||||
std::string udp_firstdst(int action);
|
||||
std::string udp_numdst(int action);
|
||||
std::string udp_reconfigure(int action);
|
||||
std::string udp_srcip(int action);
|
||||
std::string udp_srcip2(int action);
|
||||
std::string udp_srcmac(int action);
|
||||
std::string udp_srcmac2(int action);
|
||||
std::string udp_validate(int action);
|
||||
std::string update(int action);
|
||||
std::string updatedetectorserver(int action);
|
||||
std::string updatekernel(int action);
|
||||
std::string updatemode(int action);
|
||||
std::string user(int action);
|
||||
std::string v_a(int action);
|
||||
std::string v_b(int action);
|
||||
std::string v_c(int action);
|
||||
std::string v_chip(int action);
|
||||
std::string v_d(int action);
|
||||
std::string v_io(int action);
|
||||
std::string v_limit(int action);
|
||||
std::string vchip_comp_adc(int action);
|
||||
std::string vchip_comp_fe(int action);
|
||||
std::string vchip_cs(int action);
|
||||
std::string vchip_opa_1st(int action);
|
||||
std::string vchip_opa_fd(int action);
|
||||
std::string vchip_ref_comp_fe(int action);
|
||||
std::string versions(int action);
|
||||
std::string veto(int action);
|
||||
std::string vetoalg(int action);
|
||||
std::string vetofile(int action);
|
||||
std::string vetophoton(int action);
|
||||
std::string vetoref(int action);
|
||||
std::string vetostream(int action);
|
||||
std::string virtualFunction(int action);
|
||||
std::string vm_a(int action);
|
||||
std::string vm_b(int action);
|
||||
std::string vm_c(int action);
|
||||
std::string vm_d(int action);
|
||||
std::string vm_io(int action);
|
||||
std::string zmqhwm(int action);
|
||||
std::string zmqip(int action);
|
||||
std::string zmqport(int action);
|
||||
|
||||
std::vector<std::string> args;
|
||||
std::string cmd;
|
||||
Detector *det;
|
||||
int det_id{-1};
|
||||
int rx_id{-1};
|
||||
|
||||
private:
|
||||
bool ReplaceIfDeprecated(std::string &command);
|
||||
using FunctionMap = std::map<std::string, std::string (Caller::*)(int)>;
|
||||
using StringMap = std::map<std::string, std::string>;
|
||||
Detector *ptr; // pointer to the detector that executes the command
|
||||
|
||||
static void EmptyDataCallBack(detectorData *data, uint64_t frameIndex,
|
||||
uint32_t subFrameIndex, void *this_pointer);
|
||||
|
||||
FunctionMap functions{
|
||||
{"list", &Caller::list},
|
||||
|
||||
{"acquire", &Caller::acquire},
|
||||
{"activate", &Caller::activate},
|
||||
{"adcclk", &Caller::adcclk},
|
||||
{"adcenable", &Caller::adcenable},
|
||||
{"adcenable10g", &Caller::adcenable10g},
|
||||
{"adcindex", &Caller::adcindex},
|
||||
{"adcinvert", &Caller::adcinvert},
|
||||
{"adclist", &Caller::adclist},
|
||||
{"adcname", &Caller::adcname},
|
||||
{"adcphase", &Caller::adcphase},
|
||||
{"adcpipeline", &Caller::adcpipeline},
|
||||
{"adcreg", &Caller::adcreg},
|
||||
{"adcvpp", &Caller::adcvpp},
|
||||
{"apulse", &Caller::apulse},
|
||||
{"asamples", &Caller::asamples},
|
||||
{"autocompdisable", &Caller::autocompdisable},
|
||||
{"badchannels", &Caller::badchannels},
|
||||
{"blockingtrigger", &Caller::blockingtrigger},
|
||||
{"burstmode", &Caller::burstmode},
|
||||
{"burstperiod", &Caller::burstperiod},
|
||||
{"bursts", &Caller::bursts},
|
||||
{"burstsl", &Caller::burstsl},
|
||||
{"bustest", &Caller::bustest},
|
||||
{"cdsgain", &Caller::cdsgain},
|
||||
{"chipversion", &Caller::chipversion},
|
||||
{"clearbit", &Caller::clearbit},
|
||||
{"clearbusy", &Caller::clearbusy},
|
||||
{"clearroi", &Caller::clearroi},
|
||||
{"clientversion", &Caller::clientversion},
|
||||
{"clkdiv", &Caller::clkdiv},
|
||||
{"clkfreq", &Caller::clkfreq},
|
||||
{"clkphase", &Caller::clkphase},
|
||||
{"collectionmode", &Caller::collectionmode},
|
||||
{"column", &Caller::column},
|
||||
{"compdisabletime", &Caller::compdisabletime},
|
||||
{"confadc", &Caller::confadc},
|
||||
{"config", &Caller::config},
|
||||
{"configtransceiver", &Caller::configtransceiver},
|
||||
{"counters", &Caller::counters},
|
||||
{"currentsource", &Caller::currentsource},
|
||||
{"dac", &Caller::dac},
|
||||
{"dacindex", &Caller::dacindex},
|
||||
{"daclist", &Caller::daclist},
|
||||
{"dacname", &Caller::dacname},
|
||||
{"dacvalues", &Caller::dacvalues},
|
||||
{"datastream", &Caller::datastream},
|
||||
{"dbitclk", &Caller::dbitclk},
|
||||
{"dbitphase", &Caller::dbitphase},
|
||||
{"dbitpipeline", &Caller::dbitpipeline},
|
||||
{"defaultdac", &Caller::defaultdac},
|
||||
{"defaultpattern", &Caller::defaultpattern},
|
||||
{"delay", &Caller::delay},
|
||||
{"delayl", &Caller::delayl},
|
||||
{"detectorserverversion", &Caller::detectorserverversion},
|
||||
{"detsize", &Caller::detsize},
|
||||
{"diodelay", &Caller::diodelay},
|
||||
{"dpulse", &Caller::dpulse},
|
||||
{"dr", &Caller::dr},
|
||||
{"drlist", &Caller::drlist},
|
||||
{"dsamples", &Caller::dsamples},
|
||||
{"execcommand", &Caller::execcommand},
|
||||
{"exptime", &Caller::exptime},
|
||||
{"exptime1", &Caller::exptime1},
|
||||
{"exptime2", &Caller::exptime2},
|
||||
{"exptime3", &Caller::exptime3},
|
||||
{"exptimel", &Caller::exptimel},
|
||||
{"extrastoragecells", &Caller::extrastoragecells},
|
||||
{"extsampling", &Caller::extsampling},
|
||||
{"extsamplingsrc", &Caller::extsamplingsrc},
|
||||
{"extsig", &Caller::extsig},
|
||||
{"fformat", &Caller::fformat},
|
||||
{"filtercells", &Caller::filtercells},
|
||||
{"filterresistor", &Caller::filterresistor},
|
||||
{"findex", &Caller::findex},
|
||||
{"firmwaretest", &Caller::firmwaretest},
|
||||
{"firmwareversion", &Caller::firmwareversion},
|
||||
{"fliprows", &Caller::fliprows},
|
||||
{"flowcontrol10g", &Caller::flowcontrol10g},
|
||||
{"fmaster", &Caller::fmaster},
|
||||
{"fname", &Caller::fname},
|
||||
{"foverwrite", &Caller::foverwrite},
|
||||
{"fpath", &Caller::fpath},
|
||||
{"framecounter", &Caller::framecounter},
|
||||
{"frames", &Caller::frames},
|
||||
{"framesl", &Caller::framesl},
|
||||
{"frametime", &Caller::frametime},
|
||||
{"free", &Caller::free},
|
||||
{"fwrite", &Caller::fwrite},
|
||||
{"gaincaps", &Caller::gaincaps},
|
||||
{"gainmode", &Caller::gainmode},
|
||||
{"gappixels", &Caller::gappixels},
|
||||
{"gatedelay", &Caller::gatedelay},
|
||||
{"gatedelay1", &Caller::gatedelay1},
|
||||
{"gatedelay2", &Caller::gatedelay2},
|
||||
{"gatedelay3", &Caller::gatedelay3},
|
||||
{"gates", &Caller::gates},
|
||||
{"getbit", &Caller::getbit},
|
||||
{"hardwareversion", &Caller::hardwareversion},
|
||||
{"highvoltage", &Caller::highvoltage},
|
||||
{"hostname", &Caller::hostname},
|
||||
{"im_a", &Caller::im_a},
|
||||
{"im_b", &Caller::im_b},
|
||||
{"im_c", &Caller::im_c},
|
||||
{"im_d", &Caller::im_d},
|
||||
{"im_io", &Caller::im_io},
|
||||
{"imagetest", &Caller::imagetest},
|
||||
{"initialchecks", &Caller::initialchecks},
|
||||
{"inj_ch", &Caller::inj_ch},
|
||||
{"interpolation", &Caller::interpolation},
|
||||
{"interruptsubframe", &Caller::interruptsubframe},
|
||||
{"kernelversion", &Caller::kernelversion},
|
||||
{"lastclient", &Caller::lastclient},
|
||||
{"led", &Caller::led},
|
||||
{"lock", &Caller::lock},
|
||||
{"master", &Caller::master},
|
||||
{"maxadcphaseshift", &Caller::maxadcphaseshift},
|
||||
{"maxclkphaseshift", &Caller::maxclkphaseshift},
|
||||
{"maxdbitphaseshift", &Caller::maxdbitphaseshift},
|
||||
{"measuredperiod", &Caller::measuredperiod},
|
||||
{"measuredsubperiod", &Caller::measuredsubperiod},
|
||||
{"moduleid", &Caller::moduleid},
|
||||
{"nextframenumber", &Caller::nextframenumber},
|
||||
{"nmod", &Caller::nmod},
|
||||
{"numinterfaces", &Caller::numinterfaces},
|
||||
{"overflow", &Caller::overflow},
|
||||
{"packageversion", &Caller::packageversion},
|
||||
{"parallel", &Caller::parallel},
|
||||
{"parameters", &Caller::parameters},
|
||||
{"partialreset", &Caller::partialreset},
|
||||
{"patfname", &Caller::patfname},
|
||||
{"patioctrl", &Caller::patioctrl},
|
||||
{"patlimits", &Caller::patlimits},
|
||||
{"patloop", &Caller::patloop},
|
||||
{"patloop0", &Caller::patloop0},
|
||||
{"patloop1", &Caller::patloop1},
|
||||
{"patloop2", &Caller::patloop2},
|
||||
{"patmask", &Caller::patmask},
|
||||
{"patnloop", &Caller::patnloop},
|
||||
{"patnloop0", &Caller::patnloop0},
|
||||
{"patnloop1", &Caller::patnloop1},
|
||||
{"patnloop2", &Caller::patnloop2},
|
||||
{"patsetbit", &Caller::patsetbit},
|
||||
{"patternX", &Caller::pattern},
|
||||
{"patternstart", &Caller::patternstart},
|
||||
{"patwait", &Caller::patwait},
|
||||
{"patwait0", &Caller::patwait0},
|
||||
{"patwait1", &Caller::patwait1},
|
||||
{"patwait2", &Caller::patwait2},
|
||||
{"patwaittime", &Caller::patwaittime},
|
||||
{"patwaittime0", &Caller::patwaittime0},
|
||||
{"patwaittime1", &Caller::patwaittime1},
|
||||
{"patwaittime2", &Caller::patwaittime2},
|
||||
{"patword", &Caller::patword},
|
||||
{"pedestalmode", &Caller::pedestalmode},
|
||||
{"period", &Caller::period},
|
||||
{"periodl", &Caller::periodl},
|
||||
{"polarity", &Caller::polarity},
|
||||
{"port", &Caller::port},
|
||||
{"powerchip", &Caller::powerchip},
|
||||
{"powerindex", &Caller::powerindex},
|
||||
{"powerlist", &Caller::powerlist},
|
||||
{"powername", &Caller::powername},
|
||||
{"powervalues", &Caller::powervalues},
|
||||
{"programfpga", &Caller::programfpga},
|
||||
{"pulse", &Caller::pulse},
|
||||
{"pulsechip", &Caller::pulsechip},
|
||||
{"pulsenmove", &Caller::pulsenmove},
|
||||
{"pumpprobe", &Caller::pumpprobe},
|
||||
{"quad", &Caller::quad},
|
||||
{"ratecorr", &Caller::ratecorr},
|
||||
{"readnrows", &Caller::readnrows},
|
||||
{"readout", &Caller::readout},
|
||||
{"readoutspeed", &Caller::readoutspeed},
|
||||
{"readoutspeedlist", &Caller::readoutspeedlist},
|
||||
{"rebootcontroller", &Caller::rebootcontroller},
|
||||
{"reg", &Caller::reg},
|
||||
{"resetdacs", &Caller::resetdacs},
|
||||
{"resetfpga", &Caller::resetfpga},
|
||||
{"roi", &Caller::roi},
|
||||
{"romode", &Caller::romode},
|
||||
{"row", &Caller::row},
|
||||
{"runclk", &Caller::runclk},
|
||||
{"runtime", &Caller::runtime},
|
||||
{"rx_arping", &Caller::rx_arping},
|
||||
{"rx_clearroi", &Caller::rx_clearroi},
|
||||
{"rx_dbitlist", &Caller::rx_dbitlist},
|
||||
{"rx_dbitoffset", &Caller::rx_dbitoffset},
|
||||
{"rx_discardpolicy", &Caller::rx_discardpolicy},
|
||||
{"rx_fifodepth", &Caller::rx_fifodepth},
|
||||
{"rx_frameindex", &Caller::rx_frameindex},
|
||||
{"rx_framescaught", &Caller::rx_framescaught},
|
||||
{"rx_framesperfile", &Caller::rx_framesperfile},
|
||||
{"rx_hostname", &Caller::rx_hostname},
|
||||
{"rx_jsonaddheader", &Caller::rx_jsonaddheader},
|
||||
{"rx_jsonpara", &Caller::rx_jsonpara},
|
||||
{"rx_lastclient", &Caller::rx_lastclient},
|
||||
{"rx_lock", &Caller::rx_lock},
|
||||
{"rx_missingpackets", &Caller::rx_missingpackets},
|
||||
{"rx_padding", &Caller::rx_padding},
|
||||
{"rx_printconfig", &Caller::rx_printconfig},
|
||||
{"rx_realudpsocksize", &Caller::rx_realudpsocksize},
|
||||
{"rx_roi", &Caller::rx_roi},
|
||||
{"rx_silent", &Caller::rx_silent},
|
||||
{"rx_start", &Caller::rx_start},
|
||||
{"rx_status", &Caller::rx_status},
|
||||
{"rx_stop", &Caller::rx_stop},
|
||||
{"rx_tcpport", &Caller::rx_tcpport},
|
||||
{"rx_threads", &Caller::rx_threads},
|
||||
{"rx_udpsocksize", &Caller::rx_udpsocksize},
|
||||
{"rx_version", &Caller::rx_version},
|
||||
{"rx_zmqfreq", &Caller::rx_zmqfreq},
|
||||
{"rx_zmqhwm", &Caller::rx_zmqhwm},
|
||||
{"rx_zmqip", &Caller::rx_zmqip},
|
||||
{"rx_zmqport", &Caller::rx_zmqport},
|
||||
{"rx_zmqstartfnum", &Caller::rx_zmqstartfnum},
|
||||
{"rx_zmqstream", &Caller::rx_zmqstream},
|
||||
{"samples", &Caller::samples},
|
||||
{"savepattern", &Caller::savepattern},
|
||||
{"scan", &Caller::scan},
|
||||
{"scanerrmsg", &Caller::scanerrmsg},
|
||||
{"selinterface", &Caller::selinterface},
|
||||
{"serialnumber", &Caller::serialnumber},
|
||||
{"setbit", &Caller::setbit},
|
||||
{"settings", &Caller::settings},
|
||||
{"settingslist", &Caller::settingslist},
|
||||
{"settingspath", &Caller::settingspath},
|
||||
{"signalindex", &Caller::signalindex},
|
||||
{"signallist", &Caller::signallist},
|
||||
{"signalname", &Caller::signalname},
|
||||
{"sleep", &Caller::sleep},
|
||||
{"slowadc", &Caller::slowadc},
|
||||
{"slowadcindex", &Caller::slowadcindex},
|
||||
{"slowadclist", &Caller::slowadclist},
|
||||
{"slowadcname", &Caller::slowadcname},
|
||||
{"slowadcvalues", &Caller::slowadcvalues},
|
||||
{"start", &Caller::start},
|
||||
{"status", &Caller::status},
|
||||
{"stop", &Caller::stop},
|
||||
{"stopport", &Caller::stopport},
|
||||
{"storagecell_delay", &Caller::storagecell_delay},
|
||||
{"storagecell_start", &Caller::storagecell_start},
|
||||
{"subdeadtime", &Caller::subdeadtime},
|
||||
{"subexptime", &Caller::subexptime},
|
||||
{"sync", &Caller::sync},
|
||||
{"syncclk", &Caller::syncclk},
|
||||
{"temp_10ge", &Caller::temp_10ge},
|
||||
{"temp_adc", &Caller::temp_adc},
|
||||
{"temp_control", &Caller::temp_control},
|
||||
{"temp_dcdc", &Caller::temp_dcdc},
|
||||
{"temp_event", &Caller::temp_event},
|
||||
{"temp_fpga", &Caller::temp_fpga},
|
||||
{"temp_fpgaext", &Caller::temp_fpgaext},
|
||||
{"temp_fpgafl", &Caller::temp_fpgafl},
|
||||
{"temp_fpgafr", &Caller::temp_fpgafr},
|
||||
{"temp_slowadc", &Caller::temp_slowadc},
|
||||
{"temp_sodl", &Caller::temp_sodl},
|
||||
{"temp_sodr", &Caller::temp_sodr},
|
||||
{"temp_threshold", &Caller::temp_threshold},
|
||||
{"templist", &Caller::templist},
|
||||
{"tempvalues", &Caller::tempvalues},
|
||||
{"tengiga", &Caller::tengiga},
|
||||
{"threshold", &Caller::threshold},
|
||||
{"thresholdnotb", &Caller::threshold},
|
||||
{"timing", &Caller::timing},
|
||||
{"timing_info_decoder", &Caller::timing_info_decoder},
|
||||
{"timinglist", &Caller::timinglist},
|
||||
{"timingsource", &Caller::timingsource},
|
||||
{"top", &Caller::top},
|
||||
{"transceiverenable", &Caller::transceiverenable},
|
||||
{"trigger", &Caller::trigger},
|
||||
{"triggers", &Caller::triggers},
|
||||
{"triggersl", &Caller::triggersl},
|
||||
{"trimbits", &Caller::trimbits},
|
||||
{"trimen", &Caller::trimen},
|
||||
{"trimval", &Caller::trimval},
|
||||
{"tsamples", &Caller::tsamples},
|
||||
{"txdelay", &Caller::txdelay},
|
||||
{"txdelay_frame", &Caller::txdelay_frame},
|
||||
{"txdelay_left", &Caller::txdelay_left},
|
||||
{"txdelay_right", &Caller::txdelay_right},
|
||||
{"type", &Caller::type},
|
||||
{"udp_cleardst", &Caller::udp_cleardst},
|
||||
{"udp_dstip", &Caller::udp_dstip},
|
||||
{"udp_dstip2", &Caller::udp_dstip2},
|
||||
{"udp_dstlist", &Caller::udp_dstlist},
|
||||
{"udp_dstmac", &Caller::udp_dstmac},
|
||||
{"udp_dstmac2", &Caller::udp_dstmac2},
|
||||
{"udp_dstport", &Caller::udp_dstport},
|
||||
{"udp_dstport2", &Caller::udp_dstport2},
|
||||
{"udp_firstdst", &Caller::udp_firstdst},
|
||||
{"udp_numdst", &Caller::udp_numdst},
|
||||
{"udp_reconfigure", &Caller::udp_reconfigure},
|
||||
{"udp_srcip", &Caller::udp_srcip},
|
||||
{"udp_srcip2", &Caller::udp_srcip2},
|
||||
{"udp_srcmac", &Caller::udp_srcmac},
|
||||
{"udp_srcmac2", &Caller::udp_srcmac2},
|
||||
{"udp_validate", &Caller::udp_validate},
|
||||
{"update", &Caller::update},
|
||||
{"updatedetectorserver", &Caller::updatedetectorserver},
|
||||
{"updatekernel", &Caller::updatekernel},
|
||||
{"updatemode", &Caller::updatemode},
|
||||
{"user", &Caller::user},
|
||||
{"v_a", &Caller::v_a},
|
||||
{"v_b", &Caller::v_b},
|
||||
{"v_c", &Caller::v_c},
|
||||
{"v_chip", &Caller::v_chip},
|
||||
{"v_d", &Caller::v_d},
|
||||
{"v_io", &Caller::v_io},
|
||||
{"v_limit", &Caller::v_limit},
|
||||
{"vchip_comp_adc", &Caller::vchip_comp_adc},
|
||||
{"vchip_comp_fe", &Caller::vchip_comp_fe},
|
||||
{"vchip_cs", &Caller::vchip_cs},
|
||||
{"vchip_opa_1st", &Caller::vchip_opa_1st},
|
||||
{"vchip_opa_fd", &Caller::vchip_opa_fd},
|
||||
{"vchip_ref_comp_fe", &Caller::vchip_ref_comp_fe},
|
||||
{"versions", &Caller::versions},
|
||||
{"veto", &Caller::veto},
|
||||
{"vetoalg", &Caller::vetoalg},
|
||||
{"vetofile", &Caller::vetofile},
|
||||
{"vetophoton", &Caller::vetophoton},
|
||||
{"vetoref", &Caller::vetoref},
|
||||
{"vetostream", &Caller::vetostream},
|
||||
{"virtual", &Caller::virtualFunction},
|
||||
{"vm_a", &Caller::vm_a},
|
||||
{"vm_b", &Caller::vm_b},
|
||||
{"vm_c", &Caller::vm_c},
|
||||
{"vm_d", &Caller::vm_d},
|
||||
{"vm_io", &Caller::vm_io},
|
||||
{"zmqhwm", &Caller::zmqhwm},
|
||||
{"zmqip", &Caller::zmqip},
|
||||
{"zmqport", &Caller::zmqport}
|
||||
|
||||
};
|
||||
|
||||
StringMap deprecated_functions{
|
||||
|
||||
{"detectorversion", "firmwareversion"},
|
||||
{"softwareversion", "detectorserverversion"},
|
||||
{"receiverversion", "rx_version"},
|
||||
{"detectornumber", "serialnumber"},
|
||||
{"thisversion", "clientversion"},
|
||||
{"detsizechan", "detsize"},
|
||||
{"trimdir", "settingspath"},
|
||||
{"settingsdir", "settingspath"},
|
||||
{"flippeddatax", "fliprows"},
|
||||
{"cycles", "triggers"},
|
||||
{"cyclesl", "triggersl"},
|
||||
{"clkdivider", "readoutspeed"},
|
||||
{"speed", "readoutspeed"},
|
||||
{"vhighvoltage", "highvoltage"},
|
||||
{"digitest", "imagetest"},
|
||||
{"filter", "filterresistor"},
|
||||
{"readnlines", "readnrows"},
|
||||
{"vtr", "vtrim"},
|
||||
{"vrf", "vrpreamp"},
|
||||
{"vrs", "vrshaper"},
|
||||
{"vcall", "vcal"},
|
||||
{"vis", "vishaper"},
|
||||
{"vshaper", "vrshaper"},
|
||||
{"vpreamp", "vrpreamp"},
|
||||
{"vshaperneg", "vrshaper_n"},
|
||||
{"viinsh", "vishaper"},
|
||||
{"vpl", "vcal_n"},
|
||||
{"vph", "vcal_p"},
|
||||
{"vthreshold", "dac"},
|
||||
{"vsvp", "dac"},
|
||||
{"vsvn", "dac"},
|
||||
{"vtrim", "dac"},
|
||||
{"vrpreamp", "dac"},
|
||||
{"vrshaper", "dac"},
|
||||
{"vtgstv", "dac"},
|
||||
{"vcmp_ll", "dac"},
|
||||
{"vcmp_lr", "dac"},
|
||||
{"vcal", "dac"},
|
||||
{"vcmp_rl", "dac"},
|
||||
{"vcmp_rr", "dac"},
|
||||
{"rxb_rb", "dac"},
|
||||
{"rxb_lb", "dac"},
|
||||
{"vcp", "dac"},
|
||||
{"vcn", "dac"},
|
||||
{"vishaper", "dac"},
|
||||
{"iodelay", "dac"},
|
||||
{"vref_ds", "dac"},
|
||||
{"vcascn_pb", "dac"},
|
||||
{"vcascp_pb", "dac"},
|
||||
{"vout_cm", "dac"},
|
||||
{"vcasc_out", "dac"},
|
||||
{"vin_cm", "dac"},
|
||||
{"vref_comp", "dac"},
|
||||
{"ib_test_c", "dac"},
|
||||
{"vrshaper_n", "dac"},
|
||||
{"vipre", "dac"},
|
||||
{"vdcsh", "dac"},
|
||||
{"vth1", "dac"},
|
||||
{"vth2", "dac"},
|
||||
{"vth3", "dac"},
|
||||
{"vcal_n", "dac"},
|
||||
{"vcal_p", "dac"},
|
||||
{"vcassh", "dac"},
|
||||
{"vcas", "dac"},
|
||||
{"vicin", "dac"},
|
||||
{"vipre_out", "dac"},
|
||||
{"vref_h_adc", "dac"},
|
||||
{"vb_comp_fe", "dac"},
|
||||
{"vb_comp_adc", "dac"},
|
||||
{"vcom_cds", "dac"},
|
||||
{"vref_rstore", "dac"},
|
||||
{"vb_opa_1st", "dac"},
|
||||
{"vref_comp_fe", "dac"},
|
||||
{"vcom_adc1", "dac"},
|
||||
{"vref_prech", "dac"},
|
||||
{"vref_l_adc", "dac"},
|
||||
{"vref_cds", "dac"},
|
||||
{"vb_cs", "dac"},
|
||||
{"vb_opa_fd", "dac"},
|
||||
{"vcom_adc2", "dac"},
|
||||
{"vb_ds", "dac"},
|
||||
{"vb_comp", "dac"},
|
||||
{"vb_pixbuf", "dac"},
|
||||
{"vin_com", "dac"},
|
||||
{"vdd_prot", "dac"},
|
||||
{"vbp_colbuf", "dac"},
|
||||
{"vb_sda", "dac"},
|
||||
{"vcasc_sfp", "dac"},
|
||||
{"vipre_cds", "dac"},
|
||||
{"ibias_sfp", "dac"},
|
||||
{"defaultdacs", "resetdacs"},
|
||||
{"busy", "clearbusy"},
|
||||
{"receiver", "rx_status"},
|
||||
{"framescaught", "rx_framescaught"},
|
||||
{"startingfnum", "nextframenumber"},
|
||||
{"detectorip", "udp_srcip"},
|
||||
{"detectorip2", "udp_srcip2"},
|
||||
{"detectormac", "udp_srcmac"},
|
||||
{"detectormac2", "udp_srcmac2"},
|
||||
{"rx_udpip", "udp_dstip"},
|
||||
{"rx_udpip2", "udp_dstip2"},
|
||||
{"rx_udpmac", "udp_dstmac"},
|
||||
{"rx_udpmac2", "udp_dstmac2"},
|
||||
{"rx_udpport", "udp_dstport"},
|
||||
{"rx_udpport2", "udp_dstport2"},
|
||||
{"flowcontrol_10g", "flowcontrol10g"},
|
||||
{"txndelay_frame", "txdelay_frame"},
|
||||
{"txndelay_left", "txdelay_left"},
|
||||
{"txndelay_right", "txdelay_right"},
|
||||
{"r_silent", "rx_silent"},
|
||||
{"r_discardpolicy", "rx_discardpolicy"},
|
||||
{"r_padding", "rx_padding"},
|
||||
{"r_lock", "rx_lock"},
|
||||
{"r_lastclient", "rx_lastclient"},
|
||||
{"fileformat", "fformat"},
|
||||
{"outdir", "fpath"},
|
||||
{"index", "findex"},
|
||||
{"enablefwrite", "fwrite"},
|
||||
{"masterfile", "fmaster"},
|
||||
{"overwrite", "foverwrite"},
|
||||
{"r_framesperfile", "rx_framesperfile"},
|
||||
{"r_readfreq", "rx_zmqfreq"},
|
||||
{"rx_readfreq", "rx_zmqfreq"},
|
||||
{"rx_datastream", "rx_zmqstream"},
|
||||
{"resmat", "partialreset"},
|
||||
{"storagecells", "extrastoragecells"},
|
||||
{"auto_comp_disable", "autocompdisable"},
|
||||
{"comp_disable_time", "compdisabletime"},
|
||||
{"adc", "slowadc"},
|
||||
{"flags", "romode"},
|
||||
{"i_a", "im_a"},
|
||||
{"i_b", "im_b"},
|
||||
{"i_c", "im_c"},
|
||||
{"i_d", "im_d"},
|
||||
{"i_io", "im_io"},
|
||||
{"copydetectorserver", "updatedetectorserver"},
|
||||
{"nframes", "framecounter"},
|
||||
{"now", "runtime"},
|
||||
{"timestamp", "frametime"},
|
||||
{"frameindex", "rx_frameindex"},
|
||||
|
||||
};
|
||||
};
|
||||
|
||||
} // namespace sls
|
||||
1277
slsDetectorSoftware/src/CallerSpecial.cpp
Normal file
1277
slsDetectorSoftware/src/CallerSpecial.cpp
Normal file
File diff suppressed because it is too large
Load Diff
@@ -1,22 +1,12 @@
|
||||
// SPDX-License-Identifier: LGPL-3.0-or-other
|
||||
// Copyright (C) 2021 Contributors to the SLS Detector Package
|
||||
|
||||
/*
|
||||
This file is used to generate the command line binaries
|
||||
(sls_detector_get/put/acquire/help). By defines in CMake
|
||||
we get the different files.
|
||||
|
||||
*/
|
||||
#include "sls/Detector.h"
|
||||
|
||||
#include "Caller.h"
|
||||
#include "CmdParser.h"
|
||||
#include "CmdProxy.h"
|
||||
#include "sls/sls_detector_defs.h"
|
||||
#include "inferAction.h"
|
||||
#include "sls/Detector.h"
|
||||
#include "sls/logger.h"
|
||||
#include "sls/versionAPI.h"
|
||||
#include <cstring> //strcmp
|
||||
|
||||
#include <iostream>
|
||||
int main(int argc, char *argv[]) {
|
||||
|
||||
// To genereate sepereate binaries for put, get, acquire and help
|
||||
#ifdef PUT
|
||||
int action = slsDetectorDefs::PUT_ACTION;
|
||||
@@ -37,6 +27,9 @@ int main(int argc, char *argv[]) {
|
||||
#ifdef HELP
|
||||
int action = slsDetectorDefs::HELP_ACTION;
|
||||
#endif
|
||||
#ifdef INFER
|
||||
int action = -1;
|
||||
#endif
|
||||
|
||||
// Check for --version in the arguments
|
||||
for (int i = 1; i < argc; ++i) {
|
||||
@@ -49,7 +42,6 @@ int main(int argc, char *argv[]) {
|
||||
sls::CmdParser parser;
|
||||
parser.Parse(argc, argv);
|
||||
|
||||
// If we called sls_detector_acquire, add the acquire command
|
||||
if (action == slsDetectorDefs::READOUT_ACTION ||
|
||||
action == slsDetectorDefs::READOUT_ZMQ_ACTION)
|
||||
parser.setCommand("acquire");
|
||||
@@ -57,7 +49,6 @@ int main(int argc, char *argv[]) {
|
||||
if (parser.isHelp())
|
||||
action = slsDetectorDefs::HELP_ACTION;
|
||||
else {
|
||||
|
||||
// Free shared memory should work also without a detector
|
||||
// if we have an option for verify in the detector constructor
|
||||
// we could avoid this but clutter the code
|
||||
@@ -70,22 +61,30 @@ int main(int argc, char *argv[]) {
|
||||
}
|
||||
}
|
||||
|
||||
// prevent mem size check
|
||||
if (parser.command() == "config" && action == slsDetectorDefs::PUT_ACTION) {
|
||||
sls::freeSharedMemory(parser.multi_id());
|
||||
}
|
||||
|
||||
sls::InferAction inferAction = sls::InferAction();
|
||||
|
||||
try {
|
||||
std::unique_ptr<sls::Detector> det{nullptr};
|
||||
if (action != slsDetectorDefs::HELP_ACTION) {
|
||||
det = sls::make_unique<sls::Detector>(parser.multi_id());
|
||||
if (action == -1) {
|
||||
action = inferAction.infer(parser);
|
||||
std::string actionString =
|
||||
(action == slsDetectorDefs::GET_ACTION) ? "GET" : "PUT";
|
||||
std::cout << "inferred action: " << actionString << std::endl;
|
||||
}
|
||||
sls::CmdProxy proxy(det.get());
|
||||
proxy.Call(parser.command(), parser.arguments(), parser.detector_id(),
|
||||
action, std::cout, parser.receiver_id());
|
||||
} catch (const sls::RuntimeError &e) {
|
||||
|
||||
std::unique_ptr<sls::Detector> d{nullptr};
|
||||
if (action != slsDetectorDefs::HELP_ACTION) {
|
||||
d = sls::make_unique<sls::Detector>(parser.multi_id());
|
||||
}
|
||||
sls::Caller c(d.get());
|
||||
|
||||
c.call(parser.command(), parser.arguments(), parser.detector_id(),
|
||||
action, std::cout, parser.receiver_id());
|
||||
} catch (sls::RuntimeError &e) {
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
exit(EXIT_SUCCESS);
|
||||
}
|
||||
@@ -20,7 +20,6 @@ reason that the header file is not exposed.
|
||||
#include <vector>
|
||||
|
||||
namespace sls {
|
||||
|
||||
class CmdParser {
|
||||
public:
|
||||
void Parse(int argc, const char *const argv[]);
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -3,8 +3,8 @@
|
||||
#include "sls/Detector.h"
|
||||
#include "sls/detectorData.h"
|
||||
|
||||
#include "Caller.h"
|
||||
#include "CmdParser.h"
|
||||
#include "CmdProxy.h"
|
||||
#include "CtbConfig.h"
|
||||
#include "DetectorImpl.h"
|
||||
#include "Module.h"
|
||||
@@ -23,7 +23,7 @@
|
||||
|
||||
namespace sls {
|
||||
|
||||
void freeSharedMemory(int detectorIndex, int moduleIndex) {
|
||||
void freeSharedMemory(const int detectorIndex, const int moduleIndex) {
|
||||
|
||||
// single module
|
||||
if (moduleIndex >= 0) {
|
||||
@@ -34,10 +34,10 @@ void freeSharedMemory(int detectorIndex, int moduleIndex) {
|
||||
return;
|
||||
}
|
||||
|
||||
// detector - multi module - get number of detectors from shm
|
||||
SharedMemory<sharedDetector> detectorShm(detectorIndex, -1);
|
||||
int numDetectors = 0;
|
||||
|
||||
// detector - multi module - get number of detectors from shm
|
||||
SharedMemory<sharedDetector> detectorShm(detectorIndex, -1);
|
||||
if (detectorShm.exists()) {
|
||||
detectorShm.openSharedMemory(false);
|
||||
numDetectors = detectorShm()->totalNumberOfModules;
|
||||
@@ -58,15 +58,19 @@ void freeSharedMemory(int detectorIndex, int moduleIndex) {
|
||||
using defs = slsDetectorDefs;
|
||||
|
||||
Detector::Detector(int shm_id) : pimpl(make_unique<DetectorImpl>(shm_id)) {}
|
||||
|
||||
Detector::~Detector() = default;
|
||||
|
||||
// Move constructor
|
||||
Detector::Detector(Detector &&other) noexcept = default;
|
||||
|
||||
// Move assignment operator
|
||||
Detector &Detector::operator=(Detector &&other) noexcept = default;
|
||||
|
||||
// Configuration
|
||||
void Detector::freeSharedMemory() { pimpl->freeSharedMemory(); }
|
||||
|
||||
void Detector::loadConfig(const std::string &fname) {
|
||||
int shm_id = getShmId();
|
||||
freeSharedMemory();
|
||||
freeSharedMemory(shm_id);
|
||||
pimpl = make_unique<DetectorImpl>(shm_id);
|
||||
LOG(logINFO) << "Loading configuration file: " << fname;
|
||||
loadParameters(fname);
|
||||
@@ -91,12 +95,12 @@ void Detector::loadParameters(const std::string &fname) {
|
||||
}
|
||||
|
||||
void Detector::loadParameters(const std::vector<std::string> ¶meters) {
|
||||
CmdProxy proxy(this);
|
||||
Caller caller(this);
|
||||
CmdParser parser;
|
||||
for (const auto ¤t_line : parameters) {
|
||||
parser.Parse(current_line);
|
||||
proxy.Call(parser.command(), parser.arguments(), parser.detector_id(),
|
||||
defs::PUT_ACTION, std::cout, parser.receiver_id());
|
||||
caller.call(parser.command(), parser.arguments(), parser.detector_id(),
|
||||
defs::PUT_ACTION, std::cout, parser.receiver_id());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -105,18 +109,35 @@ Result<std::string> Detector::getHostname(Positions pos) const {
|
||||
}
|
||||
|
||||
void Detector::setHostname(const std::vector<std::string> &hostname) {
|
||||
if (pimpl->hasModulesInSharedMemory()) {
|
||||
LOG(logWARNING) << "There are already module(s) in shared memory."
|
||||
"Freeing Shared memory now.";
|
||||
auto numChannels = getDetectorSize();
|
||||
auto initialChecks = getInitialChecks();
|
||||
freeSharedMemory(getShmId());
|
||||
pimpl = make_unique<DetectorImpl>(getShmId());
|
||||
setDetectorSize(numChannels);
|
||||
setInitialChecks(initialChecks);
|
||||
}
|
||||
pimpl->setHostname(hostname);
|
||||
}
|
||||
|
||||
void Detector::setVirtualDetectorServers(int numServers,
|
||||
uint16_t startingPort) {
|
||||
validatePortRange(startingPort, numServers * 2);
|
||||
pimpl->setVirtualDetectorServers(numServers, startingPort);
|
||||
|
||||
std::vector<std::string> hostnames;
|
||||
for (int i = 0; i < numServers; ++i) {
|
||||
// * 2 is for control and stop port
|
||||
hostnames.push_back(std::string("localhost:") +
|
||||
std::to_string(startingPort + i * 2));
|
||||
}
|
||||
setHostname(hostnames);
|
||||
}
|
||||
|
||||
int Detector::getShmId() const { return pimpl->getDetectorIndex(); }
|
||||
|
||||
std::string Detector::getPackageVersion() const { return RELEASE; }
|
||||
std::string Detector::getPackageVersion() const { return SLS_DET_VERSION; }
|
||||
|
||||
std::string Detector::getClientVersion() const {
|
||||
Version v(APILIB);
|
||||
@@ -208,6 +229,7 @@ std::vector<defs::detectorSettings> Detector::getSettingsList() const {
|
||||
defs::G2_LOWCAP_HIGHGAIN, defs::G2_LOWCAP_LOWGAIN,
|
||||
defs::G4_HIGHGAIN, defs::G4_LOWGAIN};
|
||||
case defs::CHIPTESTBOARD:
|
||||
case defs::XILINX_CHIPTESTBOARD:
|
||||
throw RuntimeError("Settings not implemented for this detector");
|
||||
default:
|
||||
throw RuntimeError("Unknown detector type");
|
||||
@@ -532,6 +554,7 @@ std::vector<defs::speedLevel> Detector::getReadoutSpeedList() const {
|
||||
case defs::EIGER:
|
||||
case defs::JUNGFRAU:
|
||||
case defs::MOENCH:
|
||||
case defs::MYTHEN3:
|
||||
return std::vector<defs::speedLevel>{defs::FULL_SPEED, defs::HALF_SPEED,
|
||||
defs::QUARTER_SPEED};
|
||||
case defs::GOTTHARD2:
|
||||
@@ -666,6 +689,7 @@ std::vector<defs::dacIndex> Detector::getTemperatureList() const {
|
||||
defs::TEMPERATURE_FPGA2, defs::TEMPERATURE_FPGA3};
|
||||
case defs::MYTHEN3:
|
||||
case defs::GOTTHARD2:
|
||||
case defs::XILINX_CHIPTESTBOARD:
|
||||
return std::vector<defs::dacIndex>{defs::TEMPERATURE_FPGA};
|
||||
default:
|
||||
return std::vector<defs::dacIndex>{};
|
||||
@@ -696,6 +720,7 @@ Result<int> Detector::getTemperature(defs::dacIndex index,
|
||||
case defs::MOENCH:
|
||||
case defs::MYTHEN3:
|
||||
case defs::GOTTHARD2:
|
||||
case defs::XILINX_CHIPTESTBOARD:
|
||||
for (auto &it : res) {
|
||||
it /= 1000;
|
||||
}
|
||||
@@ -743,6 +768,7 @@ std::vector<defs::dacIndex> Detector::getDacList() const {
|
||||
defs::VBP_COLBUF, defs::VIPRE, defs::VIN_CM, defs::VB_SDA,
|
||||
defs::VCASC_SFP, defs::VOUT_CM, defs::VIPRE_CDS, defs::IBIAS_SFP};
|
||||
case defs::CHIPTESTBOARD:
|
||||
case defs::XILINX_CHIPTESTBOARD:
|
||||
for (int i = 0; i != 18; ++i) {
|
||||
retval.push_back(static_cast<defs::dacIndex>(i));
|
||||
}
|
||||
@@ -905,7 +931,9 @@ void Detector::stopDetector(Positions pos) {
|
||||
case defs::EIGER:
|
||||
case defs::JUNGFRAU:
|
||||
case defs::MOENCH:
|
||||
case defs::CHIPTESTBOARD: {
|
||||
case defs::CHIPTESTBOARD:
|
||||
case defs::XILINX_CHIPTESTBOARD:
|
||||
case defs::GOTTHARD2: {
|
||||
auto res = getNextFrameNumber(pos);
|
||||
if (!res.equal()) {
|
||||
uint64_t maxVal = 0;
|
||||
@@ -1478,19 +1506,6 @@ void Detector::setRxZmqPort(uint16_t port, int module_id) {
|
||||
}
|
||||
}
|
||||
|
||||
Result<IpAddr> Detector::getRxZmqIP(Positions pos) const {
|
||||
return pimpl->Parallel(&Module::getReceiverStreamingIP, pos);
|
||||
}
|
||||
|
||||
void Detector::setRxZmqIP(const IpAddr ip, Positions pos) {
|
||||
bool previouslyReceiverStreaming = getRxZmqDataStream(pos).squash(false);
|
||||
pimpl->Parallel(&Module::setReceiverStreamingIP, pos, ip);
|
||||
if (previouslyReceiverStreaming) {
|
||||
setRxZmqDataStream(false, pos);
|
||||
setRxZmqDataStream(true, pos);
|
||||
}
|
||||
}
|
||||
|
||||
Result<uint16_t> Detector::getClientZmqPort(Positions pos) const {
|
||||
return pimpl->Parallel(&Module::getClientStreamingPort, pos);
|
||||
}
|
||||
@@ -1779,6 +1794,24 @@ void Detector::setPedestalMode(const defs::pedestalParameters par,
|
||||
pimpl->Parallel(&Module::setPedestalMode, pos, par);
|
||||
}
|
||||
|
||||
Result<defs::timingInfoDecoder>
|
||||
Detector::getTimingInfoDecoder(Positions pos) const {
|
||||
return pimpl->Parallel(&Module::getTimingInfoDecoder, pos);
|
||||
}
|
||||
|
||||
void Detector::setTimingInfoDecoder(defs::timingInfoDecoder value,
|
||||
Positions pos) {
|
||||
pimpl->Parallel(&Module::setTimingInfoDecoder, pos, value);
|
||||
}
|
||||
|
||||
Result<defs::collectionMode> Detector::getCollectionMode(Positions pos) const {
|
||||
return pimpl->Parallel(&Module::getCollectionMode, pos);
|
||||
}
|
||||
|
||||
void Detector::setCollectionMode(defs::collectionMode value, Positions pos) {
|
||||
pimpl->Parallel(&Module::setCollectionMode, pos, value);
|
||||
}
|
||||
|
||||
// Gotthard Specific
|
||||
|
||||
Result<defs::ROI> Detector::getROI(Positions pos) const {
|
||||
@@ -2079,7 +2112,9 @@ Result<int> Detector::getSYNCClock(Positions pos) const {
|
||||
}
|
||||
|
||||
std::vector<defs::dacIndex> Detector::getPowerList() const {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD) {
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD &&
|
||||
dettype != defs::XILINX_CHIPTESTBOARD) {
|
||||
throw RuntimeError("Power list not implemented for this detector");
|
||||
}
|
||||
return std::vector<defs::dacIndex>{defs::V_POWER_A, defs::V_POWER_B,
|
||||
@@ -2088,7 +2123,9 @@ std::vector<defs::dacIndex> Detector::getPowerList() const {
|
||||
}
|
||||
|
||||
std::vector<defs::dacIndex> Detector::getSlowADCList() const {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD) {
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD &&
|
||||
dettype != defs::XILINX_CHIPTESTBOARD) {
|
||||
throw RuntimeError("Slow ADC list not implemented for this detector");
|
||||
}
|
||||
return std::vector<defs::dacIndex>{
|
||||
@@ -2277,7 +2314,8 @@ void Detector::setLEDEnable(bool enable, Positions pos) {
|
||||
}
|
||||
|
||||
void Detector::setDacNames(const std::vector<std::string> names) {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
|
||||
throw RuntimeError("Named dacs only for CTB");
|
||||
pimpl->setCtbDacNames(names);
|
||||
}
|
||||
@@ -2285,7 +2323,7 @@ void Detector::setDacNames(const std::vector<std::string> names) {
|
||||
std::vector<std::string> Detector::getDacNames() const {
|
||||
std::vector<std::string> names;
|
||||
auto type = getDetectorType().squash();
|
||||
if (type == defs::CHIPTESTBOARD)
|
||||
if (type == defs::CHIPTESTBOARD || type == defs::XILINX_CHIPTESTBOARD)
|
||||
return pimpl->getCtbDacNames();
|
||||
|
||||
for (const auto &index : getDacList())
|
||||
@@ -2295,7 +2333,7 @@ std::vector<std::string> Detector::getDacNames() const {
|
||||
|
||||
defs::dacIndex Detector::getDacIndex(const std::string &name) const {
|
||||
auto type = getDetectorType().squash();
|
||||
if (type == defs::CHIPTESTBOARD) {
|
||||
if (type == defs::CHIPTESTBOARD || type == defs::XILINX_CHIPTESTBOARD) {
|
||||
auto names = getDacNames();
|
||||
auto it = std::find(names.begin(), names.end(), name);
|
||||
if (it == names.end())
|
||||
@@ -2306,32 +2344,36 @@ defs::dacIndex Detector::getDacIndex(const std::string &name) const {
|
||||
}
|
||||
|
||||
void Detector::setDacName(const defs::dacIndex i, const std::string &name) {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
|
||||
throw RuntimeError("Named dacs only for CTB");
|
||||
pimpl->setCtbDacName(i, name);
|
||||
}
|
||||
|
||||
std::string Detector::getDacName(const defs::dacIndex i) const {
|
||||
auto type = getDetectorType().squash();
|
||||
if (type == defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype == defs::CHIPTESTBOARD || dettype == defs::XILINX_CHIPTESTBOARD)
|
||||
return pimpl->getCtbDacName(i);
|
||||
return ToString(i);
|
||||
}
|
||||
|
||||
void Detector::setAdcNames(const std::vector<std::string> names) {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
|
||||
throw RuntimeError("Named adcs only for CTB");
|
||||
pimpl->setCtbAdcNames(names);
|
||||
}
|
||||
|
||||
std::vector<std::string> Detector::getAdcNames() const {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
|
||||
throw RuntimeError("Named adcs only for CTB");
|
||||
return pimpl->getCtbAdcNames();
|
||||
}
|
||||
|
||||
int Detector::getAdcIndex(const std::string &name) const {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
|
||||
throw RuntimeError("Named adcs only for CTB");
|
||||
auto names = getAdcNames();
|
||||
auto it = std::find(names.begin(), names.end(), name);
|
||||
@@ -2341,31 +2383,36 @@ int Detector::getAdcIndex(const std::string &name) const {
|
||||
}
|
||||
|
||||
void Detector::setAdcName(const int index, const std::string &name) {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
|
||||
throw RuntimeError("Named adcs only for CTB");
|
||||
pimpl->setCtbAdcName(index, name);
|
||||
}
|
||||
|
||||
std::string Detector::getAdcName(const int i) const {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
|
||||
throw RuntimeError("Named adcs only for CTB");
|
||||
return pimpl->getCtbAdcName(i);
|
||||
}
|
||||
|
||||
void Detector::setSignalNames(const std::vector<std::string> names) {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
|
||||
throw RuntimeError("Named signals only for CTB");
|
||||
pimpl->setCtbSignalNames(names);
|
||||
}
|
||||
|
||||
std::vector<std::string> Detector::getSignalNames() const {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
|
||||
throw RuntimeError("Named signals only for CTB");
|
||||
return pimpl->getCtbSignalNames();
|
||||
}
|
||||
|
||||
int Detector::getSignalIndex(const std::string &name) const {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
|
||||
throw RuntimeError("Named signals only for CTB");
|
||||
auto names = getSignalNames();
|
||||
auto it = std::find(names.begin(), names.end(), name);
|
||||
@@ -2375,31 +2422,37 @@ int Detector::getSignalIndex(const std::string &name) const {
|
||||
}
|
||||
|
||||
void Detector::setSignalName(const int index, const std::string &name) {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
|
||||
throw RuntimeError("Named signals only for CTB");
|
||||
pimpl->setCtbSignalName(index, name);
|
||||
}
|
||||
|
||||
std::string Detector::getSignalName(const int i) const {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
|
||||
throw RuntimeError("Named signals only for CTB");
|
||||
return pimpl->getCtbSignalName(i);
|
||||
}
|
||||
|
||||
void Detector::setPowerNames(const std::vector<std::string> names) {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD &&
|
||||
dettype != defs::XILINX_CHIPTESTBOARD)
|
||||
throw RuntimeError("Named powers only for CTB");
|
||||
pimpl->setCtbPowerNames(names);
|
||||
}
|
||||
|
||||
std::vector<std::string> Detector::getPowerNames() const {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
|
||||
throw RuntimeError("Named powers only for CTB");
|
||||
return pimpl->getCtbPowerNames();
|
||||
}
|
||||
|
||||
defs::dacIndex Detector::getPowerIndex(const std::string &name) const {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
|
||||
throw RuntimeError("Named powers only for CTB");
|
||||
auto names = getPowerNames();
|
||||
auto it = std::find(names.begin(), names.end(), name);
|
||||
@@ -2410,31 +2463,36 @@ defs::dacIndex Detector::getPowerIndex(const std::string &name) const {
|
||||
|
||||
void Detector::setPowerName(const defs::dacIndex index,
|
||||
const std::string &name) {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
|
||||
throw RuntimeError("Named powers only for CTB");
|
||||
pimpl->setCtbPowerName(index, name);
|
||||
}
|
||||
|
||||
std::string Detector::getPowerName(const defs::dacIndex i) const {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
|
||||
throw RuntimeError("Named powers only for CTB");
|
||||
return pimpl->getCtbPowerName(i);
|
||||
}
|
||||
|
||||
void Detector::setSlowADCNames(const std::vector<std::string> names) {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
|
||||
throw RuntimeError("Named SlowADCs only for CTB");
|
||||
pimpl->setCtbSlowADCNames(names);
|
||||
}
|
||||
|
||||
std::vector<std::string> Detector::getSlowADCNames() const {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
|
||||
throw RuntimeError("Named SlowADCs only for CTB");
|
||||
return pimpl->getCtbSlowADCNames();
|
||||
}
|
||||
|
||||
defs::dacIndex Detector::getSlowADCIndex(const std::string &name) const {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
|
||||
throw RuntimeError("Named SlowADCs only for CTB");
|
||||
auto names = getSlowADCNames();
|
||||
auto it = std::find(names.begin(), names.end(), name);
|
||||
@@ -2445,17 +2503,25 @@ defs::dacIndex Detector::getSlowADCIndex(const std::string &name) const {
|
||||
|
||||
void Detector::setSlowADCName(const defs::dacIndex index,
|
||||
const std::string &name) {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
|
||||
throw RuntimeError("Named SlowADCs only for CTB");
|
||||
pimpl->setCtbSlowADCName(index, name);
|
||||
}
|
||||
|
||||
std::string Detector::getSlowADCName(const defs::dacIndex i) const {
|
||||
if (getDetectorType().squash() != defs::CHIPTESTBOARD)
|
||||
auto dettype = getDetectorType().squash();
|
||||
if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
|
||||
throw RuntimeError("Named SlowADCs only for CTB");
|
||||
return pimpl->getCtbSlowADCName(i);
|
||||
}
|
||||
|
||||
// Xilinx Ctb Specific
|
||||
|
||||
void Detector::configureTransceiver(Positions pos) {
|
||||
pimpl->Parallel(&Module::configureTransceiver, pos);
|
||||
}
|
||||
|
||||
// Pattern
|
||||
|
||||
Result<std::string> Detector::getPatterFileName(Positions pos) const {
|
||||
@@ -2648,16 +2714,18 @@ Result<uint32_t> Detector::readRegister(uint32_t addr, Positions pos) const {
|
||||
return pimpl->Parallel(&Module::readRegister, pos, addr);
|
||||
}
|
||||
|
||||
void Detector::writeRegister(uint32_t addr, uint32_t val, Positions pos) {
|
||||
pimpl->Parallel(&Module::writeRegister, pos, addr, val);
|
||||
void Detector::writeRegister(uint32_t addr, uint32_t val, bool validate,
|
||||
Positions pos) {
|
||||
pimpl->Parallel(&Module::writeRegister, pos, addr, val, validate);
|
||||
}
|
||||
|
||||
void Detector::setBit(uint32_t addr, int bitnr, Positions pos) {
|
||||
pimpl->Parallel(&Module::setBit, pos, addr, bitnr);
|
||||
void Detector::setBit(uint32_t addr, int bitnr, bool validate, Positions pos) {
|
||||
pimpl->Parallel(&Module::setBit, pos, addr, bitnr, validate);
|
||||
}
|
||||
|
||||
void Detector::clearBit(uint32_t addr, int bitnr, Positions pos) {
|
||||
pimpl->Parallel(&Module::clearBit, pos, addr, bitnr);
|
||||
void Detector::clearBit(uint32_t addr, int bitnr, bool validate,
|
||||
Positions pos) {
|
||||
pimpl->Parallel(&Module::clearBit, pos, addr, bitnr, validate);
|
||||
}
|
||||
|
||||
Result<int> Detector::getBit(uint32_t addr, int bitnr, Positions pos) {
|
||||
|
||||
@@ -37,8 +37,6 @@ DetectorImpl::DetectorImpl(int detector_index, bool verify, bool update)
|
||||
setupDetector(verify, update);
|
||||
}
|
||||
|
||||
DetectorImpl::~DetectorImpl() = default;
|
||||
|
||||
void DetectorImpl::setupDetector(bool verify, bool update) {
|
||||
initSharedMemory(verify);
|
||||
initializeMembers(verify);
|
||||
@@ -59,51 +57,6 @@ void DetectorImpl::setAcquiringFlag(bool flag) { shm()->acquiringFlag = flag; }
|
||||
|
||||
int DetectorImpl::getDetectorIndex() const { return detectorIndex; }
|
||||
|
||||
void DetectorImpl::freeSharedMemory(int detectorIndex, int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
SharedMemory<sharedModule> moduleShm(detectorIndex, detPos);
|
||||
if (moduleShm.exists()) {
|
||||
moduleShm.removeSharedMemory();
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// multi - get number of modules from shm
|
||||
SharedMemory<sharedDetector> detectorShm(detectorIndex, -1);
|
||||
int numModules = 0;
|
||||
|
||||
if (detectorShm.exists()) {
|
||||
detectorShm.openSharedMemory(false);
|
||||
numModules = detectorShm()->totalNumberOfModules;
|
||||
detectorShm.removeSharedMemory();
|
||||
}
|
||||
|
||||
for (int i = 0; i < numModules; ++i) {
|
||||
SharedMemory<sharedModule> moduleShm(detectorIndex, i);
|
||||
moduleShm.removeSharedMemory();
|
||||
}
|
||||
|
||||
SharedMemory<CtbConfig> ctbShm(detectorIndex, -1, CtbConfig::shm_tag());
|
||||
if (ctbShm.exists())
|
||||
ctbShm.removeSharedMemory();
|
||||
}
|
||||
|
||||
void DetectorImpl::freeSharedMemory() {
|
||||
zmqSocket.clear();
|
||||
for (auto &module : modules) {
|
||||
module->freeSharedMemory();
|
||||
}
|
||||
modules.clear();
|
||||
|
||||
// clear detector shm
|
||||
shm.removeSharedMemory();
|
||||
client_downstream = false;
|
||||
|
||||
if (ctb_shm.exists())
|
||||
ctb_shm.removeSharedMemory();
|
||||
}
|
||||
|
||||
std::string DetectorImpl::getUserDetails() {
|
||||
if (modules.empty()) {
|
||||
return std::string("none");
|
||||
@@ -242,24 +195,11 @@ std::string DetectorImpl::exec(const char *cmd) {
|
||||
return result;
|
||||
}
|
||||
|
||||
void DetectorImpl::setVirtualDetectorServers(const int numdet,
|
||||
const uint16_t port) {
|
||||
std::vector<std::string> hostnames;
|
||||
for (int i = 0; i < numdet; ++i) {
|
||||
// * 2 is for control and stop port
|
||||
hostnames.push_back(std::string("localhost:") +
|
||||
std::to_string(port + i * 2));
|
||||
}
|
||||
setHostname(hostnames);
|
||||
bool DetectorImpl::hasModulesInSharedMemory() {
|
||||
return (shm.exists() && shm()->totalNumberOfModules > 0);
|
||||
}
|
||||
|
||||
void DetectorImpl::setHostname(const std::vector<std::string> &name) {
|
||||
// do not free always to allow the previous detsize/ initialchecks command
|
||||
if (shm.exists() && shm()->totalNumberOfModules != 0) {
|
||||
LOG(logWARNING) << "There are already module(s) in shared memory."
|
||||
"Freeing Shared memory now.";
|
||||
freeSharedMemory();
|
||||
}
|
||||
// could be called after freeing shm from API
|
||||
if (!shm.exists()) {
|
||||
setupDetector();
|
||||
@@ -272,7 +212,8 @@ void DetectorImpl::setHostname(const std::vector<std::string> &name) {
|
||||
// Here we know the detector type and can add ctb shared memory
|
||||
// if needed, CTB dac names are only on detector level
|
||||
|
||||
if (shm()->detType == defs::CHIPTESTBOARD) {
|
||||
if (shm()->detType == defs::CHIPTESTBOARD ||
|
||||
shm()->detType == defs::XILINX_CHIPTESTBOARD) {
|
||||
if (ctb_shm.exists())
|
||||
ctb_shm.openSharedMemory(true);
|
||||
else
|
||||
@@ -291,8 +232,8 @@ void DetectorImpl::addModule(const std::string &name) {
|
||||
|
||||
// gotthard cannot have more than 2 modules (50um=1, 25um=2
|
||||
if ((type == GOTTHARD || type == GOTTHARD2) && modules.size() > 2) {
|
||||
freeSharedMemory();
|
||||
throw RuntimeError("Gotthard cannot have more than 2 modules");
|
||||
throw RuntimeError("Gotthard cannot have more than 2 modules. Please "
|
||||
"free the shared memory and start again.");
|
||||
}
|
||||
|
||||
auto pos = modules.size();
|
||||
@@ -336,7 +277,19 @@ void DetectorImpl::updateDetectorSize() {
|
||||
if (detSizeX > 1 && detSizeX <= maxChanX) {
|
||||
maxChanX = detSizeX;
|
||||
}
|
||||
if (maxChanX < modSize.x) {
|
||||
std::stringstream os;
|
||||
os << "The max det size in x dim (" << maxChanX
|
||||
<< ") is less than the module size in x dim (" << modSize.x
|
||||
<< "). Probably using shared memory of a different detector "
|
||||
"type. Please free and try again.";
|
||||
throw RuntimeError(os.str());
|
||||
}
|
||||
nModx = maxChanX / modSize.x;
|
||||
if (nModx == 0) {
|
||||
throw RuntimeError(
|
||||
"number of modules in x dimension is 0. Unable to proceed.");
|
||||
}
|
||||
nMody = size() / nModx;
|
||||
if ((maxChanX % modSize.x) > 0) {
|
||||
++nMody;
|
||||
@@ -350,7 +303,18 @@ void DetectorImpl::updateDetectorSize() {
|
||||
if (detSizeY > 1 && detSizeY <= maxChanY) {
|
||||
maxChanY = detSizeY;
|
||||
}
|
||||
if (maxChanY < modSize.y) {
|
||||
std::stringstream os;
|
||||
os << "The max det size in y dim (" << maxChanY
|
||||
<< ") is less than the module size in y dim (" << modSize.y
|
||||
<< "). Probably using shared memory of a different detector "
|
||||
"type. Please free and try again.";
|
||||
throw RuntimeError(os.str());
|
||||
}
|
||||
nMody = maxChanY / modSize.y;
|
||||
if (nMody == 0)
|
||||
throw RuntimeError(
|
||||
"number of modules in y dimension is 0. Unable to proceed.");
|
||||
nModx = size() / nMody;
|
||||
if ((maxChanY % modSize.y) > 0) {
|
||||
++nModx;
|
||||
@@ -389,7 +353,8 @@ slsDetectorDefs::xy DetectorImpl::getNumberOfChannels() const {
|
||||
}
|
||||
|
||||
void DetectorImpl::setNumberOfChannels(const slsDetectorDefs::xy c) {
|
||||
if (size() > 1) {
|
||||
// detsize is set before hostname
|
||||
if (size() >= 1) {
|
||||
throw RuntimeError(
|
||||
"Set the number of channels before setting hostname.");
|
||||
}
|
||||
@@ -615,7 +580,7 @@ void DetectorImpl::readFrameFromReceiver() {
|
||||
memset(multiframe.get(), 0xFF, multisize);
|
||||
}
|
||||
|
||||
completeImage = (numZmqRunning == (int)zmqSocket.size());
|
||||
completeImage = true;
|
||||
|
||||
// get each frame
|
||||
for (unsigned int isocket = 0; isocket < zmqSocket.size(); ++isocket) {
|
||||
@@ -632,7 +597,6 @@ void DetectorImpl::readFrameFromReceiver() {
|
||||
// parse error, version error or end of acquisition for
|
||||
// socket
|
||||
runningList[isocket] = false;
|
||||
completeImage = false;
|
||||
--numZmqRunning;
|
||||
continue;
|
||||
}
|
||||
@@ -711,7 +675,8 @@ void DetectorImpl::readFrameFromReceiver() {
|
||||
uint32_t yoffset = coordY * nPixelsY;
|
||||
uint32_t singledetrowoffset = nPixelsX * bytesPerPixel;
|
||||
uint32_t rowoffset = nX * singledetrowoffset;
|
||||
if (shm()->detType == CHIPTESTBOARD) {
|
||||
if (shm()->detType == CHIPTESTBOARD ||
|
||||
shm()->detType == defs::XILINX_CHIPTESTBOARD) {
|
||||
singledetrowoffset = size;
|
||||
}
|
||||
LOG(logDEBUG1)
|
||||
@@ -1382,7 +1347,7 @@ void DetectorImpl::stopDetector(Positions pos) {
|
||||
|
||||
void DetectorImpl::printProgress(double progress) {
|
||||
// spaces for python printout
|
||||
std::cout << " " << std::fixed << std::setprecision(2) << std::setw(6)
|
||||
std::cout << " " << std::fixed << std::setprecision(2) << std::setw(10)
|
||||
<< progress << " \%";
|
||||
std::cout << '\r' << std::flush;
|
||||
}
|
||||
@@ -1744,7 +1709,8 @@ void DetectorImpl::verifyUniqueHost(
|
||||
}
|
||||
|
||||
defs::ROI DetectorImpl::getRxROI() const {
|
||||
if (shm()->detType == CHIPTESTBOARD) {
|
||||
if (shm()->detType == CHIPTESTBOARD ||
|
||||
shm()->detType == defs::XILINX_CHIPTESTBOARD) {
|
||||
throw RuntimeError("RxRoi not implemented for this Detector");
|
||||
}
|
||||
if (modules.size() == 0) {
|
||||
@@ -1819,7 +1785,8 @@ defs::ROI DetectorImpl::getRxROI() const {
|
||||
}
|
||||
|
||||
void DetectorImpl::setRxROI(const defs::ROI arg) {
|
||||
if (shm()->detType == CHIPTESTBOARD) {
|
||||
if (shm()->detType == CHIPTESTBOARD ||
|
||||
shm()->detType == defs::XILINX_CHIPTESTBOARD) {
|
||||
throw RuntimeError("RxRoi not implemented for this Detector");
|
||||
}
|
||||
if (modules.size() == 0) {
|
||||
|
||||
@@ -5,6 +5,7 @@
|
||||
#include "CtbConfig.h"
|
||||
#include "SharedMemory.h"
|
||||
#include "sls/Result.h"
|
||||
#include "sls/ZmqSocket.h"
|
||||
#include "sls/logger.h"
|
||||
#include "sls/sls_detector_defs.h"
|
||||
|
||||
@@ -19,7 +20,6 @@
|
||||
|
||||
namespace sls {
|
||||
|
||||
class ZmqSocket;
|
||||
class detectorData;
|
||||
class Module;
|
||||
|
||||
@@ -79,11 +79,6 @@ class DetectorImpl : public virtual slsDetectorDefs {
|
||||
explicit DetectorImpl(int detector_index = 0, bool verify = true,
|
||||
bool update = true);
|
||||
|
||||
/**
|
||||
* Destructor
|
||||
*/
|
||||
virtual ~DetectorImpl();
|
||||
|
||||
template <class CT> struct NonDeduced { using type = CT; };
|
||||
template <typename RT, typename... CT>
|
||||
Result<RT> Parallel(RT (Module::*somefunc)(CT...),
|
||||
@@ -198,14 +193,6 @@ class DetectorImpl : public virtual slsDetectorDefs {
|
||||
/** return detector index in shared memory */
|
||||
int getDetectorIndex() const;
|
||||
|
||||
/** Free specific shared memory from the command line without creating
|
||||
* object */
|
||||
static void freeSharedMemory(int detectorIndex, int detPos = -1);
|
||||
|
||||
/** Free all modules from current multi Id shared memory and delete members
|
||||
*/
|
||||
void freeSharedMemory();
|
||||
|
||||
/** Get user details of shared memory */
|
||||
std::string getUserDetails();
|
||||
|
||||
@@ -215,12 +202,7 @@ class DetectorImpl : public virtual slsDetectorDefs {
|
||||
* default enabled */
|
||||
void setInitialChecks(const bool value);
|
||||
|
||||
/**
|
||||
* Connect to Virtual Detector Servers at local host
|
||||
* @param numdet number of modules
|
||||
* @param port starting port number
|
||||
*/
|
||||
void setVirtualDetectorServers(const int numdet, const uint16_t port);
|
||||
bool hasModulesInSharedMemory();
|
||||
|
||||
/** Sets the hostname of all sls modules in shared memory and updates
|
||||
* local cache */
|
||||
@@ -452,7 +434,7 @@ class DetectorImpl : public virtual slsDetectorDefs {
|
||||
/** data streaming (down stream) enabled in client (zmq sckets created) */
|
||||
bool client_downstream{false};
|
||||
std::vector<std::unique_ptr<ZmqSocket>> zmqSocket;
|
||||
volatile int numZmqRunning{0};
|
||||
std::atomic<int> numZmqRunning{0};
|
||||
|
||||
/** mutex to synchronize main and data processing threads */
|
||||
mutable std::mutex mp;
|
||||
|
||||
319
slsDetectorSoftware/src/HelpDacs.cpp
Normal file
319
slsDetectorSoftware/src/HelpDacs.cpp
Normal file
@@ -0,0 +1,319 @@
|
||||
// SPDX-License-Identifier: LGPL-3.0-or-other
|
||||
// Copyright (C) 2021 Contributors to the SLS Detector Package
|
||||
#include "sls/sls_detector_defs.h"
|
||||
#include "sls/string_utils.h"
|
||||
#include <sstream>
|
||||
|
||||
namespace sls {
|
||||
|
||||
std::string GetHelpDac(std::string dac) {
|
||||
if (sls::is_int(dac)) {
|
||||
return std::string("[dac name] [dac or mV value] [(optional unit) mV] "
|
||||
"\n\t[Ctb] Use dac index for dac name.");
|
||||
}
|
||||
if (dac == "vthreshold") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger][Mythen3] "
|
||||
"Detector threshold voltage for single photon counters.\n\t[Eiger] "
|
||||
"Sets vcmp_ll, vcmp_lr, vcmp_rl, vcmp_rr and vcp to the same "
|
||||
"value. \n\t[Mythen3] Sets vth1, vth2 and vth3 to the same value "
|
||||
"for enabled counters.");
|
||||
}
|
||||
if (dac == "vsvp") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ?? ");
|
||||
}
|
||||
if (dac == "vsvn") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] \n\t[Eiger] "
|
||||
"Dac for ?? \n\t[Mythen3] voltage to define "
|
||||
"feedback resistance of the first shaper");
|
||||
}
|
||||
if (dac == "vtrim") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ?? "
|
||||
"\n\t[Mythen3] Dac for the voltage defining the trim bit size.");
|
||||
}
|
||||
if (dac == "vrpreamp") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] \n\t[Eiger] "
|
||||
"Dac for ?? \n\t[Mythen3] voltage to define the "
|
||||
"preamplifier feedback resistance.");
|
||||
}
|
||||
if (dac == "vrshaper") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] \n\t[Eiger] "
|
||||
"Dac for ?? \n\t[Mythen3] voltage to define "
|
||||
"feedback resistance of the first shaper");
|
||||
}
|
||||
if (dac == "vtgstv") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "vcmp_ll") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "vcmp_lr") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "vcal") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "vcmp_rl") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "vcmp_rr") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "rxb_rb") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "rxb_lb") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "vcp") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "vcn") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "vishaper") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "iodelay") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "vref_ds") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] "
|
||||
"\n\t[Gotthard][Jungfrau] Dac for ??");
|
||||
}
|
||||
if (dac == "vcascn_pb") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard] Dac for ??");
|
||||
}
|
||||
if (dac == "vcascp_pb") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard] Dac for ??");
|
||||
}
|
||||
if (dac == "vout_cm") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] "
|
||||
"\n\t[Gotthard] Dac for ??\n\t[Moench] Dac for 5");
|
||||
}
|
||||
if (dac == "vcasc_out") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard] Dac for ??");
|
||||
}
|
||||
if (dac == "vin_cm") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] "
|
||||
"\n\t[Gotthard] Dac for ??\n\t[Moench] Dac for 2");
|
||||
}
|
||||
if (dac == "vref_comp") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] "
|
||||
"\n\t[Gotthard][Jungfrau] Dac for ??");
|
||||
}
|
||||
if (dac == "ib_test_c") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard] Dac for ??");
|
||||
}
|
||||
if (dac == "vrshaper_n") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] voltage to "
|
||||
"define feedback resistance of the second shaper.");
|
||||
}
|
||||
if (dac == "vipre") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
|
||||
"preamplifier's input transistor current.\n\t[Moench] Dac for 1");
|
||||
}
|
||||
if (dac == "vdcsh") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
|
||||
"reference (DC) voltage for the shaper.");
|
||||
}
|
||||
if (dac == "vth1") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for first "
|
||||
"detector threshold voltage. Overwrites even if counter disabled.");
|
||||
}
|
||||
if (dac == "vth2") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for "
|
||||
"second detector threshold voltage. Overwrites even if counter "
|
||||
"disabled.");
|
||||
}
|
||||
if (dac == "vth3") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for third "
|
||||
"detector threshold voltage. Overwrites even if counter disabled.");
|
||||
}
|
||||
if (dac == "vcal_n") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
|
||||
"low voltage for analog pulsing.");
|
||||
}
|
||||
if (dac == "vcal_p") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
|
||||
"high voltage for analog pulsing.");
|
||||
}
|
||||
if (dac == "vcassh") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
|
||||
"shaper's cascode voltage.");
|
||||
}
|
||||
if (dac == "vcas") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
|
||||
"preamplifier's cascode voltage.");
|
||||
}
|
||||
if (dac == "vicin") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
|
||||
"bias current for the comparator.");
|
||||
}
|
||||
if (dac == "vipre_out") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for "
|
||||
"preamplifier's output transistor current.");
|
||||
}
|
||||
if (dac == "vref_h_adc") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
|
||||
"reference voltage high of ADC.");
|
||||
}
|
||||
if (dac == "vb_comp_fe") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
|
||||
"comparator current of analogue front end.");
|
||||
}
|
||||
if (dac == "vb_comp_adc") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
|
||||
"comparator current of ADC.");
|
||||
}
|
||||
if (dac == "vcom_cds") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
|
||||
"common mode voltage of CDS stage.");
|
||||
}
|
||||
if (dac == "vref_rstore") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] "
|
||||
"\n\t[Gotthard2] Dac for reference charging voltage "
|
||||
"of temparory storage cell in high gain.");
|
||||
}
|
||||
if (dac == "vb_opa_1st") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] dac dac for "
|
||||
"opa current for driving the other DACs in chip.");
|
||||
}
|
||||
if (dac == "vref_comp_fe") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
|
||||
"reference voltage of the comparator of analogue front end.");
|
||||
}
|
||||
if (dac == "vcom_adc1") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
|
||||
"common mode voltage of ADC DAC bank 1.");
|
||||
}
|
||||
if (dac == "vref_prech") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] "
|
||||
"\n\t[Gotthard2][Jungfrau] "
|
||||
"Dac for reference votlage for precharing the preamplifier.");
|
||||
}
|
||||
if (dac == "vref_l_adc") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
|
||||
"reference voltage low for ADC.");
|
||||
}
|
||||
if (dac == "vref_cds") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
|
||||
"reference voltage of CDS applied to the temporary storage cell in "
|
||||
"medium and low gain.");
|
||||
}
|
||||
if (dac == "vb_cs") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
|
||||
"current injection into preamplifier.");
|
||||
}
|
||||
if (dac == "vb_opa_fd") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
|
||||
"current for CDS opa stage.");
|
||||
}
|
||||
if (dac == "vcom_adc2") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
|
||||
"common mode voltage of ADC DAC bank 2.");
|
||||
}
|
||||
if (dac == "vb_ds") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] "
|
||||
"\n\t[Jungfrau] Dac for ??");
|
||||
}
|
||||
if (dac == "vb_comp") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] "
|
||||
"\n\t[Jungfrau] Dac for ??");
|
||||
}
|
||||
if (dac == "vb_pixbuf") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] "
|
||||
"\n\t[Jungfrau] Dac for ??");
|
||||
}
|
||||
if (dac == "vin_com") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] "
|
||||
"\n\t[Jungfrau] Dac for ??");
|
||||
}
|
||||
if (dac == "vdd_prot") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] "
|
||||
"\n\t[Jungfrau] Dac for ??");
|
||||
}
|
||||
if (dac == "vbp_colbuf") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Moench] Dac for 0");
|
||||
}
|
||||
if (dac == "vb_sda") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Moench] Dac for 3");
|
||||
}
|
||||
if (dac == "vcasc_sfp") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Moench] Dac for 4");
|
||||
}
|
||||
if (dac == "vipre_cds") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Moench] Dac for 6");
|
||||
}
|
||||
if (dac == "ibias_sfp") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Moench] Dac for 7");
|
||||
}
|
||||
|
||||
// clang-format off
|
||||
if (dac == "vtgstv") { return std::string(""); }
|
||||
// clang-format on
|
||||
|
||||
throw sls::RuntimeError("Unknown dac command");
|
||||
}
|
||||
|
||||
std::string GetHelpDacWrapper(const std::string &cmd,
|
||||
const std::vector<std::string> &args) {
|
||||
std::ostringstream os;
|
||||
os << cmd << ' ';
|
||||
if (args.size() == 0) {
|
||||
os << GetHelpDac(std::to_string(0)) << '\n';
|
||||
} else {
|
||||
os << args[0] << ' ' << GetHelpDac(args[0]) << '\n';
|
||||
}
|
||||
return os.str();
|
||||
}
|
||||
|
||||
} // namespace sls
|
||||
@@ -1,305 +1,13 @@
|
||||
// SPDX-License-Identifier: LGPL-3.0-or-other
|
||||
// Copyright (C) 2021 Contributors to the SLS Detector Package
|
||||
#include "sls/string_utils.h"
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace sls {
|
||||
|
||||
std::string GetHelpDac(std::string dac) {
|
||||
if (sls::is_int(dac)) {
|
||||
return std::string("[dac name] [dac or mV value] [(optional unit) mV] "
|
||||
"\n\t[Ctb] Use dac index for dac name.");
|
||||
}
|
||||
if (dac == "vthreshold") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger][Mythen3] "
|
||||
"Detector threshold voltage for single photon counters.\n\t[Eiger] "
|
||||
"Sets vcmp_ll, vcmp_lr, vcmp_rl, vcmp_rr and vcp to the same "
|
||||
"value. \n\t[Mythen3] Sets vth1, vth2 and vth3 to the same value "
|
||||
"for enabled counters.");
|
||||
}
|
||||
if (dac == "vsvp") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ?? ");
|
||||
}
|
||||
if (dac == "vsvn") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] \n\t[Eiger] "
|
||||
"Dac for ?? \n\t[Mythen3] voltage to define "
|
||||
"feedback resistance of the first shaper");
|
||||
}
|
||||
if (dac == "vtrim") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ?? "
|
||||
"\n\t[Mythen3] Dac for the voltage defining the trim bit size.");
|
||||
}
|
||||
if (dac == "vrpreamp") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] \n\t[Eiger] "
|
||||
"Dac for ?? \n\t[Mythen3] voltage to define the "
|
||||
"preamplifier feedback resistance.");
|
||||
}
|
||||
if (dac == "vrshaper") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] \n\t[Eiger] "
|
||||
"Dac for ?? \n\t[Mythen3] voltage to define "
|
||||
"feedback resistance of the first shaper");
|
||||
}
|
||||
if (dac == "vtgstv") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "vcmp_ll") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "vcmp_lr") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "vcal") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "vcmp_rl") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "vcmp_rr") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "rxb_rb") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "rxb_lb") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "vcp") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "vcn") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "vishaper") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "iodelay") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Eiger] Dac for ??");
|
||||
}
|
||||
if (dac == "vref_ds") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] "
|
||||
"\n\t[Gotthard][Jungfrau] Dac for ??");
|
||||
}
|
||||
if (dac == "vcascn_pb") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard] Dac for ??");
|
||||
}
|
||||
if (dac == "vcascp_pb") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard] Dac for ??");
|
||||
}
|
||||
if (dac == "vout_cm") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] "
|
||||
"\n\t[Gotthard] Dac for ??\n\t[Moench] Dac for 5");
|
||||
}
|
||||
if (dac == "vcasc_out") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard] Dac for ??");
|
||||
}
|
||||
if (dac == "vin_cm") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] "
|
||||
"\n\t[Gotthard] Dac for ??\n\t[Moench] Dac for 2");
|
||||
}
|
||||
if (dac == "vref_comp") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] "
|
||||
"\n\t[Gotthard][Jungfrau] Dac for ??");
|
||||
}
|
||||
if (dac == "ib_test_c") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard] Dac for ??");
|
||||
}
|
||||
if (dac == "vrshaper_n") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] voltage to "
|
||||
"define feedback resistance of the second shaper.");
|
||||
}
|
||||
if (dac == "vipre") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
|
||||
"preamplifier's input transistor current.\n\t[Moench] Dac for 1");
|
||||
}
|
||||
if (dac == "vdcsh") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
|
||||
"reference (DC) voltage for the shaper.");
|
||||
}
|
||||
if (dac == "vth1") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for first "
|
||||
"detector threshold voltage. Overwrites even if counter disabled.");
|
||||
}
|
||||
if (dac == "vth2") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for "
|
||||
"second detector threshold voltage. Overwrites even if counter "
|
||||
"disabled.");
|
||||
}
|
||||
if (dac == "vth3") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for third "
|
||||
"detector threshold voltage. Overwrites even if counter disabled.");
|
||||
}
|
||||
if (dac == "vcal_n") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
|
||||
"low voltage for analog pulsing.");
|
||||
}
|
||||
if (dac == "vcal_p") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
|
||||
"high voltage for analog pulsing.");
|
||||
}
|
||||
if (dac == "vcassh") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
|
||||
"shaper's cascode voltage.");
|
||||
}
|
||||
if (dac == "vcas") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
|
||||
"preamplifier's cascode voltage.");
|
||||
}
|
||||
if (dac == "vicin") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for the "
|
||||
"bias current for the comparator.");
|
||||
}
|
||||
if (dac == "vipre_out") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Mythen3] Dac for "
|
||||
"preamplifier's output transistor current.");
|
||||
}
|
||||
if (dac == "vref_h_adc") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
|
||||
"reference voltage high of ADC.");
|
||||
}
|
||||
if (dac == "vb_comp_fe") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
|
||||
"comparator current of analogue front end.");
|
||||
}
|
||||
if (dac == "vb_comp_adc") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
|
||||
"comparator current of ADC.");
|
||||
}
|
||||
if (dac == "vcom_cds") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
|
||||
"common mode voltage of CDS stage.");
|
||||
}
|
||||
if (dac == "vref_rstore") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] "
|
||||
"\n\t[Gotthard2] Dac for reference charging voltage "
|
||||
"of temparory storage cell in high gain.");
|
||||
}
|
||||
if (dac == "vb_opa_1st") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] dac dac for "
|
||||
"opa current for driving the other DACs in chip.");
|
||||
}
|
||||
if (dac == "vref_comp_fe") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
|
||||
"reference voltage of the comparator of analogue front end.");
|
||||
}
|
||||
if (dac == "vcom_adc1") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
|
||||
"common mode voltage of ADC DAC bank 1.");
|
||||
}
|
||||
if (dac == "vref_prech") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] "
|
||||
"\n\t[Gotthard2][Jungfrau] "
|
||||
"Dac for reference votlage for precharing the preamplifier.");
|
||||
}
|
||||
if (dac == "vref_l_adc") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
|
||||
"reference voltage low for ADC.");
|
||||
}
|
||||
if (dac == "vref_cds") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
|
||||
"reference voltage of CDS applied to the temporary storage cell in "
|
||||
"medium and low gain.");
|
||||
}
|
||||
if (dac == "vb_cs") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
|
||||
"current injection into preamplifier.");
|
||||
}
|
||||
if (dac == "vb_opa_fd") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
|
||||
"current for CDS opa stage.");
|
||||
}
|
||||
if (dac == "vcom_adc2") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Gotthard2] Dac for "
|
||||
"common mode voltage of ADC DAC bank 2.");
|
||||
}
|
||||
if (dac == "vb_ds") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] "
|
||||
"\n\t[Jungfrau] Dac for ??");
|
||||
}
|
||||
if (dac == "vb_comp") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] "
|
||||
"\n\t[Jungfrau] Dac for ??");
|
||||
}
|
||||
if (dac == "vb_pixbuf") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] "
|
||||
"\n\t[Jungfrau] Dac for ??");
|
||||
}
|
||||
if (dac == "vin_com") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] "
|
||||
"\n\t[Jungfrau] Dac for ??");
|
||||
}
|
||||
if (dac == "vdd_prot") {
|
||||
return std::string("[dac or mV value][(optional unit) mV] "
|
||||
"\n\t[Jungfrau] Dac for ??");
|
||||
}
|
||||
if (dac == "vbp_colbuf") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Moench] Dac for 0");
|
||||
}
|
||||
if (dac == "vb_sda") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Moench] Dac for 3");
|
||||
}
|
||||
if (dac == "vcasc_sfp") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Moench] Dac for 4");
|
||||
}
|
||||
if (dac == "vipre_cds") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Moench] Dac for 6");
|
||||
}
|
||||
if (dac == "ibias_sfp") {
|
||||
return std::string(
|
||||
"[dac or mV value][(optional unit) mV] \n\t[Moench] Dac for 7");
|
||||
}
|
||||
std::string GetHelpDac(std::string dac);
|
||||
|
||||
// clang-format off
|
||||
if (dac == "vtgstv") { return std::string(""); }
|
||||
// clang-format on
|
||||
|
||||
throw sls::RuntimeError("Unknown dac command");
|
||||
}
|
||||
std::string GetHelpDacWrapper(const std::string &cmd,
|
||||
const std::vector<std::string> &args);
|
||||
|
||||
} // namespace sls
|
||||
|
||||
@@ -53,14 +53,6 @@ Module::Module(int det_id, int module_index, bool verify)
|
||||
initSharedMemory(type, det_id, verify);
|
||||
}
|
||||
|
||||
Module::~Module() = default;
|
||||
|
||||
void Module::freeSharedMemory() {
|
||||
if (shm.exists()) {
|
||||
shm.removeSharedMemory();
|
||||
}
|
||||
}
|
||||
|
||||
bool Module::isFixedPatternSharedMemoryCompatible() const {
|
||||
return (shm()->shmversion >= MODULE_SHMAPIVERSION);
|
||||
}
|
||||
@@ -169,6 +161,7 @@ Module::getTypeFromDetector(const std::string &hostname, uint16_t cport) {
|
||||
LOG(logDEBUG1) << "Getting Module type ";
|
||||
ClientSocket socket("Detector", hostname, cport);
|
||||
socket.Send(F_GET_DETECTOR_TYPE);
|
||||
socket.setFnum(F_GET_DETECTOR_TYPE);
|
||||
if (socket.Receive<int>() == FAIL) {
|
||||
throw RuntimeError("Detector (" + hostname + ", " +
|
||||
std::to_string(cport) +
|
||||
@@ -184,7 +177,8 @@ slsDetectorDefs::detectorType Module::getDetectorType() const {
|
||||
}
|
||||
|
||||
void Module::updateNumberOfChannels() {
|
||||
if (shm()->detType == CHIPTESTBOARD) {
|
||||
if (shm()->detType == CHIPTESTBOARD ||
|
||||
shm()->detType == XILINX_CHIPTESTBOARD) {
|
||||
std::array<int, 2> retvals{};
|
||||
sendToDetector(F_GET_NUM_CHANNELS, nullptr, retvals);
|
||||
shm()->nChan.x = retvals[0];
|
||||
@@ -562,6 +556,7 @@ void Module::setSynchronization(const bool value) {
|
||||
std::vector<int> Module::getBadChannels() const {
|
||||
auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
|
||||
client.Send(F_GET_BAD_CHANNELS);
|
||||
client.setFnum(F_GET_BAD_CHANNELS);
|
||||
if (client.Receive<int>() == FAIL) {
|
||||
throw DetectorError("Detector " + std::to_string(moduleIndex) +
|
||||
" returned error: " + client.readErrorMessage());
|
||||
@@ -583,6 +578,7 @@ void Module::setBadChannels(std::vector<int> list) {
|
||||
LOG(logDEBUG1) << "Sending bad channels to detector, nch:" << nch;
|
||||
auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
|
||||
client.Send(F_SET_BAD_CHANNELS);
|
||||
client.setFnum(F_SET_BAD_CHANNELS);
|
||||
client.Send(nch);
|
||||
if (nch > 0) {
|
||||
client.Send(list);
|
||||
@@ -973,6 +969,7 @@ std::vector<int64_t> Module::getFramesCaughtByReceiver() const {
|
||||
if (shm()->useReceiverFlag) {
|
||||
auto client = ReceiverSocket(shm()->rxHostname, shm()->rxTCPPort);
|
||||
client.Send(F_GET_RECEIVER_FRAMES_CAUGHT);
|
||||
client.setFnum(F_GET_RECEIVER_FRAMES_CAUGHT);
|
||||
if (client.Receive<int>() == FAIL) {
|
||||
throw ReceiverError(
|
||||
"Receiver " + std::to_string(moduleIndex) +
|
||||
@@ -995,6 +992,7 @@ std::vector<int64_t> Module::getNumMissingPackets() const {
|
||||
if (shm()->useReceiverFlag) {
|
||||
auto client = ReceiverSocket(shm()->rxHostname, shm()->rxTCPPort);
|
||||
client.Send(F_GET_NUM_MISSING_PACKETS);
|
||||
client.setFnum(F_GET_NUM_MISSING_PACKETS);
|
||||
if (client.Receive<int>() == FAIL) {
|
||||
throw ReceiverError(
|
||||
"Receiver " + std::to_string(moduleIndex) +
|
||||
@@ -1017,6 +1015,7 @@ std::vector<int64_t> Module::getReceiverCurrentFrameIndex() const {
|
||||
if (shm()->useReceiverFlag) {
|
||||
auto client = ReceiverSocket(shm()->rxHostname, shm()->rxTCPPort);
|
||||
client.Send(F_GET_RECEIVER_FRAME_INDEX);
|
||||
client.setFnum(F_GET_RECEIVER_FRAME_INDEX);
|
||||
if (client.Receive<int>() == FAIL) {
|
||||
throw ReceiverError(
|
||||
"Receiver " + std::to_string(moduleIndex) +
|
||||
@@ -1428,8 +1427,8 @@ void Module::setReceiverHostname(const std::string &hostname,
|
||||
|
||||
shm()->numUDPInterfaces = retval.udpInterfaces;
|
||||
|
||||
// to use rx_hostname if empty and also update client zmqip
|
||||
updateReceiverStreamingIP();
|
||||
// to use rx_hostname if empty
|
||||
updateClientStreamingIP();
|
||||
}
|
||||
|
||||
uint16_t Module::getReceiverPort() const { return shm()->rxTCPPort; }
|
||||
@@ -1655,21 +1654,6 @@ void Module::setReceiverStreamingPort(uint16_t port) {
|
||||
sendToReceiver(F_SET_RECEIVER_STREAMING_PORT, port, nullptr);
|
||||
}
|
||||
|
||||
IpAddr Module::getReceiverStreamingIP() const {
|
||||
return sendToReceiver<IpAddr>(F_GET_RECEIVER_STREAMING_SRC_IP);
|
||||
}
|
||||
|
||||
void Module::setReceiverStreamingIP(const IpAddr ip) {
|
||||
if (ip == 0) {
|
||||
throw RuntimeError("Invalid receiver zmq ip address");
|
||||
}
|
||||
// if client zmqip is empty, update it
|
||||
if (shm()->zmqip == 0) {
|
||||
shm()->zmqip = ip;
|
||||
}
|
||||
sendToReceiver(F_SET_RECEIVER_STREAMING_SRC_IP, ip, nullptr);
|
||||
}
|
||||
|
||||
uint16_t Module::getClientStreamingPort() const { return shm()->zmqport; }
|
||||
|
||||
void Module::setClientStreamingPort(uint16_t port) { shm()->zmqport = port; }
|
||||
@@ -1748,6 +1732,7 @@ void Module::sendReceiverRateCorrections(const std::vector<int64_t> &t) {
|
||||
<< ']';
|
||||
auto receiver = ReceiverSocket(shm()->rxHostname, shm()->rxTCPPort);
|
||||
receiver.Send(F_SET_RECEIVER_RATE_CORRECT);
|
||||
receiver.setFnum(F_SET_RECEIVER_RATE_CORRECT);
|
||||
receiver.Send(static_cast<int>(t.size()));
|
||||
receiver.Send(t);
|
||||
if (receiver.Receive<int>() == FAIL) {
|
||||
@@ -1954,6 +1939,22 @@ void Module::setPedestalMode(const defs::pedestalParameters par) {
|
||||
}
|
||||
}
|
||||
|
||||
defs::timingInfoDecoder Module::getTimingInfoDecoder() const {
|
||||
return sendToDetector<defs::timingInfoDecoder>(F_GET_TIMING_INFO_DECODER);
|
||||
}
|
||||
|
||||
void Module::setTimingInfoDecoder(const defs::timingInfoDecoder value) {
|
||||
sendToDetector(F_SET_TIMING_INFO_DECODER, static_cast<int>(value), nullptr);
|
||||
}
|
||||
|
||||
defs::collectionMode Module::getCollectionMode() const {
|
||||
return sendToDetector<defs::collectionMode>(F_GET_COLLECTION_MODE);
|
||||
}
|
||||
|
||||
void Module::setCollectionMode(const defs::collectionMode value) {
|
||||
sendToDetector(F_SET_COLLECTION_MODE, static_cast<int>(value), nullptr);
|
||||
}
|
||||
|
||||
// Gotthard Specific
|
||||
|
||||
slsDetectorDefs::ROI Module::getROI() const {
|
||||
@@ -2028,6 +2029,7 @@ void Module::sendVetoPhoton(const int chipIndex,
|
||||
const int args[]{chipIndex, nch};
|
||||
auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
|
||||
client.Send(F_SET_VETO_PHOTON);
|
||||
client.setFnum(F_SET_VETO_PHOTON);
|
||||
client.Send(args);
|
||||
client.Send(gainIndices);
|
||||
client.Send(values);
|
||||
@@ -2042,6 +2044,7 @@ void Module::getVetoPhoton(const int chipIndex,
|
||||
LOG(logDEBUG1) << "Getting veto photon [" << chipIndex << "]\n";
|
||||
auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
|
||||
client.Send(F_GET_VETO_PHOTON);
|
||||
client.setFnum(F_GET_VETO_PHOTON);
|
||||
client.Send(chipIndex);
|
||||
if (client.Receive<int>() == FAIL) {
|
||||
throw DetectorError("Detector " + std::to_string(moduleIndex) +
|
||||
@@ -2461,7 +2464,8 @@ void Module::setReadoutMode(const slsDetectorDefs::readoutMode mode) {
|
||||
sendToDetector(F_SET_READOUT_MODE, arg, nullptr);
|
||||
sendToDetectorStop(F_SET_READOUT_MODE, arg, nullptr);
|
||||
// update #nchan, as it depends on #samples, adcmask,
|
||||
if (shm()->detType == CHIPTESTBOARD) {
|
||||
if (shm()->detType == CHIPTESTBOARD ||
|
||||
shm()->detType == XILINX_CHIPTESTBOARD) {
|
||||
updateNumberOfChannels();
|
||||
}
|
||||
if (shm()->useReceiverFlag) {
|
||||
@@ -2529,6 +2533,13 @@ void Module::setLEDEnable(bool enable) {
|
||||
sendToDetector<int>(F_LED, static_cast<int>(enable));
|
||||
}
|
||||
|
||||
// Xilinx Ctb Specific
|
||||
void Module::configureTransceiver() {
|
||||
sendToDetector(F_CONFIG_TRANSCEIVER);
|
||||
LOG(logINFO) << "Module " << moduleIndex << " (" << shm()->hostname
|
||||
<< "): Transceiver configured successfully!";
|
||||
}
|
||||
|
||||
// Pattern
|
||||
std::string Module::getPatterFileName() const {
|
||||
char retval[MAX_STR_LENGTH]{};
|
||||
@@ -2539,6 +2550,7 @@ std::string Module::getPatterFileName() const {
|
||||
void Module::setPattern(const Pattern &pat, const std::string &fname) {
|
||||
auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
|
||||
client.Send(F_SET_PATTERN);
|
||||
client.setFnum(F_SET_PATTERN);
|
||||
client.Send(pat.data(), pat.size());
|
||||
char args[MAX_STR_LENGTH]{};
|
||||
strcpy_safe(args, fname.c_str());
|
||||
@@ -2649,6 +2661,7 @@ std::map<std::string, std::string> Module::getAdditionalJsonHeader() const {
|
||||
}
|
||||
auto client = ReceiverSocket(shm()->rxHostname, shm()->rxTCPPort);
|
||||
client.Send(F_GET_ADDITIONAL_JSON_HEADER);
|
||||
client.setFnum(F_GET_ADDITIONAL_JSON_HEADER);
|
||||
if (client.Receive<int>() == FAIL) {
|
||||
throw ReceiverError("Receiver " + std::to_string(moduleIndex) +
|
||||
" returned error: " + client.readErrorMessage());
|
||||
@@ -2694,6 +2707,7 @@ void Module::setAdditionalJsonHeader(
|
||||
<< ToString(jsonHeader);
|
||||
auto client = ReceiverSocket(shm()->rxHostname, shm()->rxTCPPort);
|
||||
client.Send(F_SET_ADDITIONAL_JSON_HEADER);
|
||||
client.setFnum(F_SET_ADDITIONAL_JSON_HEADER);
|
||||
client.Send(size);
|
||||
if (size > 0)
|
||||
client.Send(&buff[0], buff.size());
|
||||
@@ -2817,18 +2831,20 @@ uint32_t Module::readRegister(uint32_t addr) const {
|
||||
return sendToDetectorStop<uint32_t>(F_READ_REGISTER, addr);
|
||||
}
|
||||
|
||||
uint32_t Module::writeRegister(uint32_t addr, uint32_t val) {
|
||||
uint32_t args[]{addr, val};
|
||||
return sendToDetectorStop<uint32_t>(F_WRITE_REGISTER, args);
|
||||
void Module::writeRegister(uint32_t addr, uint32_t val, bool validate) {
|
||||
uint32_t args[]{addr, val, static_cast<uint32_t>(validate)};
|
||||
return sendToDetectorStop(F_WRITE_REGISTER, args, nullptr);
|
||||
}
|
||||
|
||||
void Module::setBit(uint32_t addr, int n) {
|
||||
uint32_t args[2] = {addr, static_cast<uint32_t>(n)};
|
||||
void Module::setBit(uint32_t addr, int n, bool validate) {
|
||||
uint32_t args[] = {addr, static_cast<uint32_t>(n),
|
||||
static_cast<uint32_t>(validate)};
|
||||
sendToDetectorStop(F_SET_BIT, args, nullptr);
|
||||
}
|
||||
|
||||
void Module::clearBit(uint32_t addr, int n) {
|
||||
uint32_t args[2] = {addr, static_cast<uint32_t>(n)};
|
||||
void Module::clearBit(uint32_t addr, int n, bool validate) {
|
||||
uint32_t args[] = {addr, static_cast<uint32_t>(n),
|
||||
static_cast<uint32_t>(validate)};
|
||||
sendToDetectorStop(F_CLEAR_BIT, args, nullptr);
|
||||
}
|
||||
|
||||
@@ -2887,6 +2903,7 @@ std::string Module::executeCommand(const std::string &cmd) {
|
||||
<< "): Sending command " << cmd;
|
||||
auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
|
||||
client.Send(F_EXEC_COMMAND);
|
||||
client.setFnum(F_EXEC_COMMAND);
|
||||
client.Send(arg);
|
||||
if (client.Receive<int>() == FAIL) {
|
||||
std::cout << '\n';
|
||||
@@ -3413,6 +3430,8 @@ const std::string Module::getDetectorAPI() const {
|
||||
return APIMYTHEN3;
|
||||
case GOTTHARD2:
|
||||
return APIGOTTHARD2;
|
||||
case XILINX_CHIPTESTBOARD:
|
||||
return APIXILINXCTB;
|
||||
default:
|
||||
throw NotImplementedError(
|
||||
"Detector type not implemented to get Detector API");
|
||||
@@ -3497,6 +3516,7 @@ void Module::setModule(sls_detector_module &module, bool trimbits) {
|
||||
}
|
||||
auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
|
||||
client.Send(F_SET_MODULE);
|
||||
client.setFnum(F_SET_MODULE);
|
||||
sendModule(&module, client);
|
||||
if (client.Receive<int>() == FAIL) {
|
||||
throw DetectorError("Module " + std::to_string(moduleIndex) +
|
||||
@@ -3509,6 +3529,7 @@ sls_detector_module Module::getModule() {
|
||||
sls_detector_module module(shm()->detType);
|
||||
auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
|
||||
client.Send(F_GET_MODULE);
|
||||
client.setFnum(F_GET_MODULE);
|
||||
if (client.Receive<int>() == FAIL) {
|
||||
throw DetectorError("Module " + std::to_string(moduleIndex) +
|
||||
" returned error: " + client.readErrorMessage());
|
||||
@@ -3601,18 +3622,19 @@ void Module::receiveModule(sls_detector_module *myMod, ClientSocket &client) {
|
||||
LOG(level) << myMod->nchan << " chans received";
|
||||
}
|
||||
|
||||
void Module::updateReceiverStreamingIP() {
|
||||
auto ip = getReceiverStreamingIP();
|
||||
void Module::updateClientStreamingIP() {
|
||||
auto ip = getClientStreamingIP();
|
||||
if (ip == 0) {
|
||||
// Hostname could be ip try to decode otherwise look up the hostname
|
||||
ip = IpAddr{shm()->rxHostname};
|
||||
if (ip == 0) {
|
||||
ip = HostnameToIp(shm()->rxHostname);
|
||||
}
|
||||
LOG(logINFO) << "Setting default receiver " << moduleIndex
|
||||
<< " streaming zmq ip to " << ip;
|
||||
LOG(logINFO) << "Setting default module " << moduleIndex
|
||||
<< " zmq ip to " << ip;
|
||||
|
||||
setClientStreamingIP(ip);
|
||||
}
|
||||
setReceiverStreamingIP(ip);
|
||||
}
|
||||
|
||||
void Module::updateRateCorrection() {
|
||||
|
||||
@@ -75,12 +75,6 @@ class Module : public virtual slsDetectorDefs {
|
||||
verify is if shared memory version matches existing one */
|
||||
explicit Module(int det_id = 0, int module_index = 0, bool verify = true);
|
||||
|
||||
virtual ~Module();
|
||||
|
||||
/** Frees shared memory and deletes shared memory structure
|
||||
Safe to call only if detector shm also deleted or its numberOfModules is
|
||||
updated */
|
||||
void freeSharedMemory();
|
||||
bool isFixedPatternSharedMemoryCompatible() const;
|
||||
std::string getHostname() const;
|
||||
|
||||
@@ -351,8 +345,6 @@ class Module : public virtual slsDetectorDefs {
|
||||
void setReceiverStreamingStartingFrame(int fnum);
|
||||
uint16_t getReceiverStreamingPort() const;
|
||||
void setReceiverStreamingPort(uint16_t port);
|
||||
IpAddr getReceiverStreamingIP() const;
|
||||
void setReceiverStreamingIP(const IpAddr ip);
|
||||
uint16_t getClientStreamingPort() const;
|
||||
void setClientStreamingPort(uint16_t port);
|
||||
IpAddr getClientStreamingIP() const;
|
||||
@@ -421,6 +413,10 @@ class Module : public virtual slsDetectorDefs {
|
||||
void setNumberOfFilterCells(int value);
|
||||
defs::pedestalParameters getPedestalMode() const;
|
||||
void setPedestalMode(defs::pedestalParameters par);
|
||||
defs::timingInfoDecoder getTimingInfoDecoder() const;
|
||||
void setTimingInfoDecoder(const defs::timingInfoDecoder enable);
|
||||
defs::collectionMode getCollectionMode() const;
|
||||
void setCollectionMode(const defs::collectionMode enable);
|
||||
|
||||
/**************************************************
|
||||
* *
|
||||
@@ -528,6 +524,13 @@ class Module : public virtual slsDetectorDefs {
|
||||
bool getLEDEnable() const;
|
||||
void setLEDEnable(bool enable);
|
||||
|
||||
/**************************************************
|
||||
* *
|
||||
* Xilinx Ctb Specific *
|
||||
* *
|
||||
* ************************************************/
|
||||
void configureTransceiver();
|
||||
|
||||
/**************************************************
|
||||
* *
|
||||
* Pattern *
|
||||
@@ -584,9 +587,9 @@ class Module : public virtual slsDetectorDefs {
|
||||
bool getUpdateMode() const;
|
||||
void setUpdateMode(const bool updatemode);
|
||||
uint32_t readRegister(uint32_t addr) const;
|
||||
uint32_t writeRegister(uint32_t addr, uint32_t val);
|
||||
void setBit(uint32_t addr, int n);
|
||||
void clearBit(uint32_t addr, int n);
|
||||
void writeRegister(uint32_t addr, uint32_t val, bool validate);
|
||||
void setBit(uint32_t addr, int n, bool validate);
|
||||
void clearBit(uint32_t addr, int n, bool validate);
|
||||
int getBit(uint32_t addr, int n);
|
||||
void executeFirmwareTest();
|
||||
void executeBusTest();
|
||||
@@ -759,7 +762,7 @@ class Module : public virtual slsDetectorDefs {
|
||||
sls_detector_module getModule();
|
||||
void sendModule(sls_detector_module *myMod, ClientSocket &client);
|
||||
void receiveModule(sls_detector_module *myMod, ClientSocket &client);
|
||||
void updateReceiverStreamingIP();
|
||||
void updateClientStreamingIP();
|
||||
|
||||
void updateRateCorrection();
|
||||
/** Template function to do linear interpolation between two points (Eiger
|
||||
|
||||
@@ -149,7 +149,7 @@ void Pattern::load(const std::string &fname) {
|
||||
level = StringTo<int>(args[iArg++]);
|
||||
} else {
|
||||
LOG(logWARNING)
|
||||
<< "Depreciated command. Please use patloop next time.";
|
||||
<< "Deprecated command. Please use patloop next time.";
|
||||
if (nargs != 2) {
|
||||
throw RuntimeError("Invalid arguments for " +
|
||||
ToString(args));
|
||||
@@ -174,7 +174,7 @@ void Pattern::load(const std::string &fname) {
|
||||
}
|
||||
level = StringTo<int>(args[iArg++]);
|
||||
} else {
|
||||
LOG(logWARNING) << "Depreciated command. Please use "
|
||||
LOG(logWARNING) << "Deprecated command. Please use "
|
||||
"patnloop next time.";
|
||||
if (nargs != 1) {
|
||||
throw RuntimeError("Invalid arguments for " +
|
||||
@@ -198,7 +198,7 @@ void Pattern::load(const std::string &fname) {
|
||||
level = StringTo<int>(args[iArg++]);
|
||||
} else {
|
||||
LOG(logWARNING)
|
||||
<< "Depreciated command. Please use patwait next time.";
|
||||
<< "Deprecated command. Please use patwait next time.";
|
||||
if (nargs != 1) {
|
||||
throw RuntimeError("Invalid arguments for " +
|
||||
ToString(args));
|
||||
@@ -220,7 +220,7 @@ void Pattern::load(const std::string &fname) {
|
||||
}
|
||||
level = StringTo<int>(args[iArg++]);
|
||||
} else {
|
||||
LOG(logWARNING) << "Depreciated command. Please use "
|
||||
LOG(logWARNING) << "Deprecated command. Please use "
|
||||
"patwaittime next time.";
|
||||
if (nargs != 1) {
|
||||
throw RuntimeError("Invalid arguments for " +
|
||||
|
||||
4684
slsDetectorSoftware/src/inferAction.cpp
Normal file
4684
slsDetectorSoftware/src/inferAction.cpp
Normal file
File diff suppressed because it is too large
Load Diff
689
slsDetectorSoftware/src/inferAction.h
Normal file
689
slsDetectorSoftware/src/inferAction.h
Normal file
@@ -0,0 +1,689 @@
|
||||
#include "CmdParser.h"
|
||||
#include <iostream>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
|
||||
namespace sls {
|
||||
class InferAction {
|
||||
public:
|
||||
InferAction() {}
|
||||
int infer(sls::CmdParser &parser, std::ostream &os = std::cout);
|
||||
std::vector<std::string> args;
|
||||
std::string cmd;
|
||||
|
||||
// generated functions
|
||||
int acquire();
|
||||
int activate();
|
||||
int adcclk();
|
||||
int adcenable();
|
||||
int adcenable10g();
|
||||
int adcindex();
|
||||
int adcinvert();
|
||||
int adclist();
|
||||
int adcname();
|
||||
int adcphase();
|
||||
int adcpipeline();
|
||||
int adcreg();
|
||||
int adcvpp();
|
||||
int apulse();
|
||||
int asamples();
|
||||
int autocompdisable();
|
||||
int badchannels();
|
||||
int blockingtrigger();
|
||||
int burstmode();
|
||||
int burstperiod();
|
||||
int bursts();
|
||||
int burstsl();
|
||||
int bustest();
|
||||
int cdsgain();
|
||||
int chipversion();
|
||||
int clearbit();
|
||||
int clearbusy();
|
||||
int clearroi();
|
||||
int clientversion();
|
||||
int clkdiv();
|
||||
int clkfreq();
|
||||
int clkphase();
|
||||
int collectionmode();
|
||||
int column();
|
||||
int compdisabletime();
|
||||
int confadc();
|
||||
int config();
|
||||
int configtransceiver();
|
||||
int counters();
|
||||
int currentsource();
|
||||
int dac();
|
||||
int dacindex();
|
||||
int daclist();
|
||||
int dacname();
|
||||
int dacvalues();
|
||||
int datastream();
|
||||
int dbitclk();
|
||||
int dbitphase();
|
||||
int dbitpipeline();
|
||||
int defaultdac();
|
||||
int defaultpattern();
|
||||
int delay();
|
||||
int delayl();
|
||||
int detectorserverversion();
|
||||
int detsize();
|
||||
int diodelay();
|
||||
int dpulse();
|
||||
int dr();
|
||||
int drlist();
|
||||
int dsamples();
|
||||
int execcommand();
|
||||
int exptime();
|
||||
int exptime1();
|
||||
int exptime2();
|
||||
int exptime3();
|
||||
int exptimel();
|
||||
int extrastoragecells();
|
||||
int extsampling();
|
||||
int extsamplingsrc();
|
||||
int extsig();
|
||||
int fformat();
|
||||
int filtercells();
|
||||
int filterresistor();
|
||||
int findex();
|
||||
int firmwaretest();
|
||||
int firmwareversion();
|
||||
int fliprows();
|
||||
int flowcontrol10g();
|
||||
int fmaster();
|
||||
int fname();
|
||||
int foverwrite();
|
||||
int fpath();
|
||||
int framecounter();
|
||||
int frames();
|
||||
int framesl();
|
||||
int frametime();
|
||||
int free();
|
||||
int fwrite();
|
||||
int gaincaps();
|
||||
int gainmode();
|
||||
int gappixels();
|
||||
int gatedelay();
|
||||
int gatedelay1();
|
||||
int gatedelay2();
|
||||
int gatedelay3();
|
||||
int gates();
|
||||
int getbit();
|
||||
int hardwareversion();
|
||||
int highvoltage();
|
||||
int hostname();
|
||||
int im_a();
|
||||
int im_b();
|
||||
int im_c();
|
||||
int im_d();
|
||||
int im_io();
|
||||
int imagetest();
|
||||
int initialchecks();
|
||||
int inj_ch();
|
||||
int interpolation();
|
||||
int interruptsubframe();
|
||||
int kernelversion();
|
||||
int lastclient();
|
||||
int led();
|
||||
int lock();
|
||||
int master();
|
||||
int maxadcphaseshift();
|
||||
int maxclkphaseshift();
|
||||
int maxdbitphaseshift();
|
||||
int measuredperiod();
|
||||
int measuredsubperiod();
|
||||
int moduleid();
|
||||
int nextframenumber();
|
||||
int nmod();
|
||||
int numinterfaces();
|
||||
int overflow();
|
||||
int packageversion();
|
||||
int parallel();
|
||||
int parameters();
|
||||
int partialreset();
|
||||
int patfname();
|
||||
int patioctrl();
|
||||
int patlimits();
|
||||
int patloop();
|
||||
int patloop0();
|
||||
int patloop1();
|
||||
int patloop2();
|
||||
int patmask();
|
||||
int patnloop();
|
||||
int patnloop0();
|
||||
int patnloop1();
|
||||
int patnloop2();
|
||||
int patsetbit();
|
||||
int pattern();
|
||||
int patternstart();
|
||||
int patwait();
|
||||
int patwait0();
|
||||
int patwait1();
|
||||
int patwait2();
|
||||
int patwaittime();
|
||||
int patwaittime0();
|
||||
int patwaittime1();
|
||||
int patwaittime2();
|
||||
int patword();
|
||||
int pedestalmode();
|
||||
int period();
|
||||
int periodl();
|
||||
int polarity();
|
||||
int port();
|
||||
int powerchip();
|
||||
int powerindex();
|
||||
int powerlist();
|
||||
int powername();
|
||||
int powervalues();
|
||||
int programfpga();
|
||||
int pulse();
|
||||
int pulsechip();
|
||||
int pulsenmove();
|
||||
int pumpprobe();
|
||||
int quad();
|
||||
int ratecorr();
|
||||
int readnrows();
|
||||
int readout();
|
||||
int readoutspeed();
|
||||
int readoutspeedlist();
|
||||
int rebootcontroller();
|
||||
int reg();
|
||||
int resetdacs();
|
||||
int resetfpga();
|
||||
int roi();
|
||||
int romode();
|
||||
int row();
|
||||
int runclk();
|
||||
int runtime();
|
||||
int rx_arping();
|
||||
int rx_clearroi();
|
||||
int rx_dbitlist();
|
||||
int rx_dbitoffset();
|
||||
int rx_discardpolicy();
|
||||
int rx_fifodepth();
|
||||
int rx_frameindex();
|
||||
int rx_framescaught();
|
||||
int rx_framesperfile();
|
||||
int rx_hostname();
|
||||
int rx_jsonaddheader();
|
||||
int rx_jsonpara();
|
||||
int rx_lastclient();
|
||||
int rx_lock();
|
||||
int rx_missingpackets();
|
||||
int rx_padding();
|
||||
int rx_printconfig();
|
||||
int rx_realudpsocksize();
|
||||
int rx_roi();
|
||||
int rx_silent();
|
||||
int rx_start();
|
||||
int rx_status();
|
||||
int rx_stop();
|
||||
int rx_tcpport();
|
||||
int rx_threads();
|
||||
int rx_udpsocksize();
|
||||
int rx_version();
|
||||
int rx_zmqfreq();
|
||||
int rx_zmqhwm();
|
||||
int rx_zmqip();
|
||||
int rx_zmqport();
|
||||
int rx_zmqstartfnum();
|
||||
int rx_zmqstream();
|
||||
int samples();
|
||||
int savepattern();
|
||||
int scan();
|
||||
int scanerrmsg();
|
||||
int selinterface();
|
||||
int serialnumber();
|
||||
int setbit();
|
||||
int settings();
|
||||
int settingslist();
|
||||
int settingspath();
|
||||
int signalindex();
|
||||
int signallist();
|
||||
int signalname();
|
||||
int sleep();
|
||||
int slowadc();
|
||||
int slowadcindex();
|
||||
int slowadclist();
|
||||
int slowadcname();
|
||||
int slowadcvalues();
|
||||
int start();
|
||||
int status();
|
||||
int stop();
|
||||
int stopport();
|
||||
int storagecell_delay();
|
||||
int storagecell_start();
|
||||
int subdeadtime();
|
||||
int subexptime();
|
||||
int sync();
|
||||
int syncclk();
|
||||
int temp_10ge();
|
||||
int temp_adc();
|
||||
int temp_control();
|
||||
int temp_dcdc();
|
||||
int temp_event();
|
||||
int temp_fpga();
|
||||
int temp_fpgaext();
|
||||
int temp_fpgafl();
|
||||
int temp_fpgafr();
|
||||
int temp_slowadc();
|
||||
int temp_sodl();
|
||||
int temp_sodr();
|
||||
int temp_threshold();
|
||||
int templist();
|
||||
int tempvalues();
|
||||
int tengiga();
|
||||
int threshold();
|
||||
int timing();
|
||||
int timing_info_decoder();
|
||||
int timinglist();
|
||||
int timingsource();
|
||||
int top();
|
||||
int transceiverenable();
|
||||
int trigger();
|
||||
int triggers();
|
||||
int triggersl();
|
||||
int trimbits();
|
||||
int trimen();
|
||||
int trimval();
|
||||
int tsamples();
|
||||
int txdelay();
|
||||
int txdelay_frame();
|
||||
int txdelay_left();
|
||||
int txdelay_right();
|
||||
int type();
|
||||
int udp_cleardst();
|
||||
int udp_dstip();
|
||||
int udp_dstip2();
|
||||
int udp_dstlist();
|
||||
int udp_dstmac();
|
||||
int udp_dstmac2();
|
||||
int udp_dstport();
|
||||
int udp_dstport2();
|
||||
int udp_firstdst();
|
||||
int udp_numdst();
|
||||
int udp_reconfigure();
|
||||
int udp_srcip();
|
||||
int udp_srcip2();
|
||||
int udp_srcmac();
|
||||
int udp_srcmac2();
|
||||
int udp_validate();
|
||||
int update();
|
||||
int updatedetectorserver();
|
||||
int updatekernel();
|
||||
int updatemode();
|
||||
int user();
|
||||
int v_a();
|
||||
int v_b();
|
||||
int v_c();
|
||||
int v_chip();
|
||||
int v_d();
|
||||
int v_io();
|
||||
int v_limit();
|
||||
int vchip_comp_adc();
|
||||
int vchip_comp_fe();
|
||||
int vchip_cs();
|
||||
int vchip_opa_1st();
|
||||
int vchip_opa_fd();
|
||||
int vchip_ref_comp_fe();
|
||||
int versions();
|
||||
int veto();
|
||||
int vetoalg();
|
||||
int vetofile();
|
||||
int vetophoton();
|
||||
int vetoref();
|
||||
int vetostream();
|
||||
int virtualFunction();
|
||||
int vm_a();
|
||||
int vm_b();
|
||||
int vm_c();
|
||||
int vm_d();
|
||||
int vm_io();
|
||||
int zmqhwm();
|
||||
int zmqip();
|
||||
int zmqport();
|
||||
// int frames();
|
||||
|
||||
private:
|
||||
using FunctionMap = std::map<std::string, int (InferAction::*)()>;
|
||||
FunctionMap functions{
|
||||
// generated functions
|
||||
|
||||
{"acquire", &InferAction::acquire},
|
||||
{"activate", &InferAction::activate},
|
||||
{"adcclk", &InferAction::adcclk},
|
||||
{"adcenable", &InferAction::adcenable},
|
||||
{"adcenable10g", &InferAction::adcenable10g},
|
||||
{"adcindex", &InferAction::adcindex},
|
||||
{"adcinvert", &InferAction::adcinvert},
|
||||
{"adclist", &InferAction::adclist},
|
||||
{"adcname", &InferAction::adcname},
|
||||
{"adcphase", &InferAction::adcphase},
|
||||
{"adcpipeline", &InferAction::adcpipeline},
|
||||
{"adcreg", &InferAction::adcreg},
|
||||
{"adcvpp", &InferAction::adcvpp},
|
||||
{"apulse", &InferAction::apulse},
|
||||
{"asamples", &InferAction::asamples},
|
||||
{"autocompdisable", &InferAction::autocompdisable},
|
||||
{"badchannels", &InferAction::badchannels},
|
||||
{"blockingtrigger", &InferAction::blockingtrigger},
|
||||
{"burstmode", &InferAction::burstmode},
|
||||
{"burstperiod", &InferAction::burstperiod},
|
||||
{"bursts", &InferAction::bursts},
|
||||
{"burstsl", &InferAction::burstsl},
|
||||
{"bustest", &InferAction::bustest},
|
||||
{"cdsgain", &InferAction::cdsgain},
|
||||
{"chipversion", &InferAction::chipversion},
|
||||
{"clearbit", &InferAction::clearbit},
|
||||
{"clearbusy", &InferAction::clearbusy},
|
||||
{"clearroi", &InferAction::clearroi},
|
||||
{"clientversion", &InferAction::clientversion},
|
||||
{"clkdiv", &InferAction::clkdiv},
|
||||
{"clkfreq", &InferAction::clkfreq},
|
||||
{"clkphase", &InferAction::clkphase},
|
||||
{"collectionmode", &InferAction::collectionmode},
|
||||
{"column", &InferAction::column},
|
||||
{"compdisabletime", &InferAction::compdisabletime},
|
||||
{"confadc", &InferAction::confadc},
|
||||
{"config", &InferAction::config},
|
||||
{"configtransceiver", &InferAction::configtransceiver},
|
||||
{"counters", &InferAction::counters},
|
||||
{"currentsource", &InferAction::currentsource},
|
||||
{"dac", &InferAction::dac},
|
||||
{"dacindex", &InferAction::dacindex},
|
||||
{"daclist", &InferAction::daclist},
|
||||
{"dacname", &InferAction::dacname},
|
||||
{"dacvalues", &InferAction::dacvalues},
|
||||
{"datastream", &InferAction::datastream},
|
||||
{"dbitclk", &InferAction::dbitclk},
|
||||
{"dbitphase", &InferAction::dbitphase},
|
||||
{"dbitpipeline", &InferAction::dbitpipeline},
|
||||
{"defaultdac", &InferAction::defaultdac},
|
||||
{"defaultpattern", &InferAction::defaultpattern},
|
||||
{"delay", &InferAction::delay},
|
||||
{"delayl", &InferAction::delayl},
|
||||
{"detectorserverversion", &InferAction::detectorserverversion},
|
||||
{"detsize", &InferAction::detsize},
|
||||
{"diodelay", &InferAction::diodelay},
|
||||
{"dpulse", &InferAction::dpulse},
|
||||
{"dr", &InferAction::dr},
|
||||
{"drlist", &InferAction::drlist},
|
||||
{"dsamples", &InferAction::dsamples},
|
||||
{"execcommand", &InferAction::execcommand},
|
||||
{"exptime", &InferAction::exptime},
|
||||
{"exptime1", &InferAction::exptime1},
|
||||
{"exptime2", &InferAction::exptime2},
|
||||
{"exptime3", &InferAction::exptime3},
|
||||
{"exptimel", &InferAction::exptimel},
|
||||
{"extrastoragecells", &InferAction::extrastoragecells},
|
||||
{"extsampling", &InferAction::extsampling},
|
||||
{"extsamplingsrc", &InferAction::extsamplingsrc},
|
||||
{"extsig", &InferAction::extsig},
|
||||
{"fformat", &InferAction::fformat},
|
||||
{"filtercells", &InferAction::filtercells},
|
||||
{"filterresistor", &InferAction::filterresistor},
|
||||
{"findex", &InferAction::findex},
|
||||
{"firmwaretest", &InferAction::firmwaretest},
|
||||
{"firmwareversion", &InferAction::firmwareversion},
|
||||
{"fliprows", &InferAction::fliprows},
|
||||
{"flowcontrol10g", &InferAction::flowcontrol10g},
|
||||
{"fmaster", &InferAction::fmaster},
|
||||
{"fname", &InferAction::fname},
|
||||
{"foverwrite", &InferAction::foverwrite},
|
||||
{"fpath", &InferAction::fpath},
|
||||
{"framecounter", &InferAction::framecounter},
|
||||
{"frames", &InferAction::frames},
|
||||
{"framesl", &InferAction::framesl},
|
||||
{"frametime", &InferAction::frametime},
|
||||
{"free", &InferAction::free},
|
||||
{"fwrite", &InferAction::fwrite},
|
||||
{"gaincaps", &InferAction::gaincaps},
|
||||
{"gainmode", &InferAction::gainmode},
|
||||
{"gappixels", &InferAction::gappixels},
|
||||
{"gatedelay", &InferAction::gatedelay},
|
||||
{"gatedelay1", &InferAction::gatedelay1},
|
||||
{"gatedelay2", &InferAction::gatedelay2},
|
||||
{"gatedelay3", &InferAction::gatedelay3},
|
||||
{"gates", &InferAction::gates},
|
||||
{"getbit", &InferAction::getbit},
|
||||
{"hardwareversion", &InferAction::hardwareversion},
|
||||
{"highvoltage", &InferAction::highvoltage},
|
||||
{"hostname", &InferAction::hostname},
|
||||
{"im_a", &InferAction::im_a},
|
||||
{"im_b", &InferAction::im_b},
|
||||
{"im_c", &InferAction::im_c},
|
||||
{"im_d", &InferAction::im_d},
|
||||
{"im_io", &InferAction::im_io},
|
||||
{"imagetest", &InferAction::imagetest},
|
||||
{"initialchecks", &InferAction::initialchecks},
|
||||
{"inj_ch", &InferAction::inj_ch},
|
||||
{"interpolation", &InferAction::interpolation},
|
||||
{"interruptsubframe", &InferAction::interruptsubframe},
|
||||
{"kernelversion", &InferAction::kernelversion},
|
||||
{"lastclient", &InferAction::lastclient},
|
||||
{"led", &InferAction::led},
|
||||
{"lock", &InferAction::lock},
|
||||
{"master", &InferAction::master},
|
||||
{"maxadcphaseshift", &InferAction::maxadcphaseshift},
|
||||
{"maxclkphaseshift", &InferAction::maxclkphaseshift},
|
||||
{"maxdbitphaseshift", &InferAction::maxdbitphaseshift},
|
||||
{"measuredperiod", &InferAction::measuredperiod},
|
||||
{"measuredsubperiod", &InferAction::measuredsubperiod},
|
||||
{"moduleid", &InferAction::moduleid},
|
||||
{"nextframenumber", &InferAction::nextframenumber},
|
||||
{"nmod", &InferAction::nmod},
|
||||
{"numinterfaces", &InferAction::numinterfaces},
|
||||
{"overflow", &InferAction::overflow},
|
||||
{"packageversion", &InferAction::packageversion},
|
||||
{"parallel", &InferAction::parallel},
|
||||
{"parameters", &InferAction::parameters},
|
||||
{"partialreset", &InferAction::partialreset},
|
||||
{"patfname", &InferAction::patfname},
|
||||
{"patioctrl", &InferAction::patioctrl},
|
||||
{"patlimits", &InferAction::patlimits},
|
||||
{"patloop", &InferAction::patloop},
|
||||
{"patloop0", &InferAction::patloop0},
|
||||
{"patloop1", &InferAction::patloop1},
|
||||
{"patloop2", &InferAction::patloop2},
|
||||
{"patmask", &InferAction::patmask},
|
||||
{"patnloop", &InferAction::patnloop},
|
||||
{"patnloop0", &InferAction::patnloop0},
|
||||
{"patnloop1", &InferAction::patnloop1},
|
||||
{"patnloop2", &InferAction::patnloop2},
|
||||
{"patsetbit", &InferAction::patsetbit},
|
||||
{"patternX", &InferAction::pattern},
|
||||
{"patternstart", &InferAction::patternstart},
|
||||
{"patwait", &InferAction::patwait},
|
||||
{"patwait0", &InferAction::patwait0},
|
||||
{"patwait1", &InferAction::patwait1},
|
||||
{"patwait2", &InferAction::patwait2},
|
||||
{"patwaittime", &InferAction::patwaittime},
|
||||
{"patwaittime0", &InferAction::patwaittime0},
|
||||
{"patwaittime1", &InferAction::patwaittime1},
|
||||
{"patwaittime2", &InferAction::patwaittime2},
|
||||
{"patword", &InferAction::patword},
|
||||
{"pedestalmode", &InferAction::pedestalmode},
|
||||
{"period", &InferAction::period},
|
||||
{"periodl", &InferAction::periodl},
|
||||
{"polarity", &InferAction::polarity},
|
||||
{"port", &InferAction::port},
|
||||
{"powerchip", &InferAction::powerchip},
|
||||
{"powerindex", &InferAction::powerindex},
|
||||
{"powerlist", &InferAction::powerlist},
|
||||
{"powername", &InferAction::powername},
|
||||
{"powervalues", &InferAction::powervalues},
|
||||
{"programfpga", &InferAction::programfpga},
|
||||
{"pulse", &InferAction::pulse},
|
||||
{"pulsechip", &InferAction::pulsechip},
|
||||
{"pulsenmove", &InferAction::pulsenmove},
|
||||
{"pumpprobe", &InferAction::pumpprobe},
|
||||
{"quad", &InferAction::quad},
|
||||
{"ratecorr", &InferAction::ratecorr},
|
||||
{"readnrows", &InferAction::readnrows},
|
||||
{"readout", &InferAction::readout},
|
||||
{"readoutspeed", &InferAction::readoutspeed},
|
||||
{"readoutspeedlist", &InferAction::readoutspeedlist},
|
||||
{"rebootcontroller", &InferAction::rebootcontroller},
|
||||
{"reg", &InferAction::reg},
|
||||
{"resetdacs", &InferAction::resetdacs},
|
||||
{"resetfpga", &InferAction::resetfpga},
|
||||
{"roi", &InferAction::roi},
|
||||
{"romode", &InferAction::romode},
|
||||
{"row", &InferAction::row},
|
||||
{"runclk", &InferAction::runclk},
|
||||
{"runtime", &InferAction::runtime},
|
||||
{"rx_arping", &InferAction::rx_arping},
|
||||
{"rx_clearroi", &InferAction::rx_clearroi},
|
||||
{"rx_dbitlist", &InferAction::rx_dbitlist},
|
||||
{"rx_dbitoffset", &InferAction::rx_dbitoffset},
|
||||
{"rx_discardpolicy", &InferAction::rx_discardpolicy},
|
||||
{"rx_fifodepth", &InferAction::rx_fifodepth},
|
||||
{"rx_frameindex", &InferAction::rx_frameindex},
|
||||
{"rx_framescaught", &InferAction::rx_framescaught},
|
||||
{"rx_framesperfile", &InferAction::rx_framesperfile},
|
||||
{"rx_hostname", &InferAction::rx_hostname},
|
||||
{"rx_jsonaddheader", &InferAction::rx_jsonaddheader},
|
||||
{"rx_jsonpara", &InferAction::rx_jsonpara},
|
||||
{"rx_lastclient", &InferAction::rx_lastclient},
|
||||
{"rx_lock", &InferAction::rx_lock},
|
||||
{"rx_missingpackets", &InferAction::rx_missingpackets},
|
||||
{"rx_padding", &InferAction::rx_padding},
|
||||
{"rx_printconfig", &InferAction::rx_printconfig},
|
||||
{"rx_realudpsocksize", &InferAction::rx_realudpsocksize},
|
||||
{"rx_roi", &InferAction::rx_roi},
|
||||
{"rx_silent", &InferAction::rx_silent},
|
||||
{"rx_start", &InferAction::rx_start},
|
||||
{"rx_status", &InferAction::rx_status},
|
||||
{"rx_stop", &InferAction::rx_stop},
|
||||
{"rx_tcpport", &InferAction::rx_tcpport},
|
||||
{"rx_threads", &InferAction::rx_threads},
|
||||
{"rx_udpsocksize", &InferAction::rx_udpsocksize},
|
||||
{"rx_version", &InferAction::rx_version},
|
||||
{"rx_zmqfreq", &InferAction::rx_zmqfreq},
|
||||
{"rx_zmqhwm", &InferAction::rx_zmqhwm},
|
||||
{"rx_zmqip", &InferAction::rx_zmqip},
|
||||
{"rx_zmqport", &InferAction::rx_zmqport},
|
||||
{"rx_zmqstartfnum", &InferAction::rx_zmqstartfnum},
|
||||
{"rx_zmqstream", &InferAction::rx_zmqstream},
|
||||
{"samples", &InferAction::samples},
|
||||
{"savepattern", &InferAction::savepattern},
|
||||
{"scan", &InferAction::scan},
|
||||
{"scanerrmsg", &InferAction::scanerrmsg},
|
||||
{"selinterface", &InferAction::selinterface},
|
||||
{"serialnumber", &InferAction::serialnumber},
|
||||
{"setbit", &InferAction::setbit},
|
||||
{"settings", &InferAction::settings},
|
||||
{"settingslist", &InferAction::settingslist},
|
||||
{"settingspath", &InferAction::settingspath},
|
||||
{"signalindex", &InferAction::signalindex},
|
||||
{"signallist", &InferAction::signallist},
|
||||
{"signalname", &InferAction::signalname},
|
||||
{"sleep", &InferAction::sleep},
|
||||
{"slowadc", &InferAction::slowadc},
|
||||
{"slowadcindex", &InferAction::slowadcindex},
|
||||
{"slowadclist", &InferAction::slowadclist},
|
||||
{"slowadcname", &InferAction::slowadcname},
|
||||
{"slowadcvalues", &InferAction::slowadcvalues},
|
||||
{"start", &InferAction::start},
|
||||
{"status", &InferAction::status},
|
||||
{"stop", &InferAction::stop},
|
||||
{"stopport", &InferAction::stopport},
|
||||
{"storagecell_delay", &InferAction::storagecell_delay},
|
||||
{"storagecell_start", &InferAction::storagecell_start},
|
||||
{"subdeadtime", &InferAction::subdeadtime},
|
||||
{"subexptime", &InferAction::subexptime},
|
||||
{"sync", &InferAction::sync},
|
||||
{"syncclk", &InferAction::syncclk},
|
||||
{"temp_10ge", &InferAction::temp_10ge},
|
||||
{"temp_adc", &InferAction::temp_adc},
|
||||
{"temp_control", &InferAction::temp_control},
|
||||
{"temp_dcdc", &InferAction::temp_dcdc},
|
||||
{"temp_event", &InferAction::temp_event},
|
||||
{"temp_fpga", &InferAction::temp_fpga},
|
||||
{"temp_fpgaext", &InferAction::temp_fpgaext},
|
||||
{"temp_fpgafl", &InferAction::temp_fpgafl},
|
||||
{"temp_fpgafr", &InferAction::temp_fpgafr},
|
||||
{"temp_slowadc", &InferAction::temp_slowadc},
|
||||
{"temp_sodl", &InferAction::temp_sodl},
|
||||
{"temp_sodr", &InferAction::temp_sodr},
|
||||
{"temp_threshold", &InferAction::temp_threshold},
|
||||
{"templist", &InferAction::templist},
|
||||
{"tempvalues", &InferAction::tempvalues},
|
||||
{"tengiga", &InferAction::tengiga},
|
||||
{"threshold", &InferAction::threshold},
|
||||
{"thresholdnotb", &InferAction::threshold},
|
||||
{"timing", &InferAction::timing},
|
||||
{"timing_info_decoder", &InferAction::timing_info_decoder},
|
||||
{"timinglist", &InferAction::timinglist},
|
||||
{"timingsource", &InferAction::timingsource},
|
||||
{"top", &InferAction::top},
|
||||
{"transceiverenable", &InferAction::transceiverenable},
|
||||
{"trigger", &InferAction::trigger},
|
||||
{"triggers", &InferAction::triggers},
|
||||
{"triggersl", &InferAction::triggersl},
|
||||
{"trimbits", &InferAction::trimbits},
|
||||
{"trimen", &InferAction::trimen},
|
||||
{"trimval", &InferAction::trimval},
|
||||
{"tsamples", &InferAction::tsamples},
|
||||
{"txdelay", &InferAction::txdelay},
|
||||
{"txdelay_frame", &InferAction::txdelay_frame},
|
||||
{"txdelay_left", &InferAction::txdelay_left},
|
||||
{"txdelay_right", &InferAction::txdelay_right},
|
||||
{"type", &InferAction::type},
|
||||
{"udp_cleardst", &InferAction::udp_cleardst},
|
||||
{"udp_dstip", &InferAction::udp_dstip},
|
||||
{"udp_dstip2", &InferAction::udp_dstip2},
|
||||
{"udp_dstlist", &InferAction::udp_dstlist},
|
||||
{"udp_dstmac", &InferAction::udp_dstmac},
|
||||
{"udp_dstmac2", &InferAction::udp_dstmac2},
|
||||
{"udp_dstport", &InferAction::udp_dstport},
|
||||
{"udp_dstport2", &InferAction::udp_dstport2},
|
||||
{"udp_firstdst", &InferAction::udp_firstdst},
|
||||
{"udp_numdst", &InferAction::udp_numdst},
|
||||
{"udp_reconfigure", &InferAction::udp_reconfigure},
|
||||
{"udp_srcip", &InferAction::udp_srcip},
|
||||
{"udp_srcip2", &InferAction::udp_srcip2},
|
||||
{"udp_srcmac", &InferAction::udp_srcmac},
|
||||
{"udp_srcmac2", &InferAction::udp_srcmac2},
|
||||
{"udp_validate", &InferAction::udp_validate},
|
||||
{"update", &InferAction::update},
|
||||
{"updatedetectorserver", &InferAction::updatedetectorserver},
|
||||
{"updatekernel", &InferAction::updatekernel},
|
||||
{"updatemode", &InferAction::updatemode},
|
||||
{"user", &InferAction::user},
|
||||
{"v_a", &InferAction::v_a},
|
||||
{"v_b", &InferAction::v_b},
|
||||
{"v_c", &InferAction::v_c},
|
||||
{"v_chip", &InferAction::v_chip},
|
||||
{"v_d", &InferAction::v_d},
|
||||
{"v_io", &InferAction::v_io},
|
||||
{"v_limit", &InferAction::v_limit},
|
||||
{"vchip_comp_adc", &InferAction::vchip_comp_adc},
|
||||
{"vchip_comp_fe", &InferAction::vchip_comp_fe},
|
||||
{"vchip_cs", &InferAction::vchip_cs},
|
||||
{"vchip_opa_1st", &InferAction::vchip_opa_1st},
|
||||
{"vchip_opa_fd", &InferAction::vchip_opa_fd},
|
||||
{"vchip_ref_comp_fe", &InferAction::vchip_ref_comp_fe},
|
||||
{"versions", &InferAction::versions},
|
||||
{"veto", &InferAction::veto},
|
||||
{"vetoalg", &InferAction::vetoalg},
|
||||
{"vetofile", &InferAction::vetofile},
|
||||
{"vetophoton", &InferAction::vetophoton},
|
||||
{"vetoref", &InferAction::vetoref},
|
||||
{"vetostream", &InferAction::vetostream},
|
||||
{"virtual", &InferAction::virtualFunction},
|
||||
{"vm_a", &InferAction::vm_a},
|
||||
{"vm_b", &InferAction::vm_b},
|
||||
{"vm_c", &InferAction::vm_c},
|
||||
{"vm_d", &InferAction::vm_d},
|
||||
{"vm_io", &InferAction::vm_io},
|
||||
{"zmqhwm", &InferAction::zmqhwm},
|
||||
{"zmqip", &InferAction::zmqip},
|
||||
{"zmqport", &InferAction::zmqport}
|
||||
|
||||
// {"frames",&InferAction::frames}
|
||||
|
||||
};
|
||||
};
|
||||
|
||||
} // namespace sls
|
||||
Reference in New Issue
Block a user