mirror of
https://github.com/slsdetectorgroup/slsDetectorPackage.git
synced 2025-05-12 07:30:03 +02:00
Dhanya Thattil
0aeb7e4417
* 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>
4336 lines
137 KiB
YAML
4336 lines
137 KiB
YAML
---
|
|
# detectors: MYTHEN3
|
|
|
|
################# TEMPLATES #################
|
|
TIME_COMMAND:
|
|
infer_action: true
|
|
help: ""
|
|
template: true
|
|
actions:
|
|
GET:
|
|
require_det_id: true
|
|
function: ''
|
|
args:
|
|
- argc: 0
|
|
output: [ OutString(t) ]
|
|
- argc: 1
|
|
arg_types: [ special::time_unit ]
|
|
output: [ "OutString(t , args[0])" ]
|
|
PUT:
|
|
function: ''
|
|
require_det_id: true
|
|
input: [ converted_time ]
|
|
input_types: [ time::ns ]
|
|
args:
|
|
- argc: 1
|
|
arg_types: [ std::string ]
|
|
|
|
separate_time_units:
|
|
input: 'args[0]'
|
|
output: [ converted_time, unit ]
|
|
output: [ 'args[0]' ]
|
|
- argc: 2
|
|
arg_types: [ int, special::time_unit ]
|
|
|
|
convert_to_time:
|
|
input: [ 'args[0]', 'args[1]' ]
|
|
output: converted_time
|
|
output: [ 'args[0]', 'args[1]' ]
|
|
|
|
TIME_GET_COMMAND:
|
|
infer_action: true
|
|
help: ""
|
|
template: true
|
|
actions:
|
|
GET:
|
|
require_det_id: true
|
|
function: ''
|
|
args:
|
|
- argc: 0
|
|
output: [ OutString(t) ]
|
|
- argc: 1
|
|
arg_types: [ special::time_unit ]
|
|
output: [ "OutString(t , args[0])" ]
|
|
|
|
STRING_COMMAND:
|
|
infer_action: true
|
|
help: ""
|
|
template: true
|
|
actions:
|
|
GET:
|
|
require_det_id: true
|
|
function: ''
|
|
argc: 0
|
|
output: [ OutString(t) ]
|
|
PUT:
|
|
function: ''
|
|
output: [ 'args.front()' ]
|
|
input: [ 'args[0]' ]
|
|
input_types: [ std::string ]
|
|
require_det_id: true
|
|
cast_input: [ false ]
|
|
argc: 1
|
|
|
|
INTEGER_COMMAND_HEX_WIDTH16:
|
|
infer_action: true
|
|
help: ""
|
|
template: true
|
|
actions:
|
|
GET:
|
|
require_det_id: true
|
|
function: ''
|
|
argc: 0
|
|
output: [ "OutStringHex(t, 16)" ]
|
|
PUT:
|
|
require_det_id: true
|
|
function: ''
|
|
argc: 1
|
|
input: [ 'args[0]' ]
|
|
cast_input: [ true ]
|
|
input_types: [ uint64_t ]
|
|
output: [ "ToStringHex(arg0, 16)" ]
|
|
|
|
INTEGER_COMMAND_HEX:
|
|
template: true
|
|
infer_action: true
|
|
help: ""
|
|
actions:
|
|
GET:
|
|
require_det_id: true
|
|
function: ''
|
|
argc: 0
|
|
output: [ "OutStringHex(t)" ]
|
|
PUT:
|
|
require_det_id: true
|
|
function: ''
|
|
argc: 1
|
|
input: [ 'args[0]' ]
|
|
cast_input: [ true ]
|
|
input_types: [ uint32_t ]
|
|
output: [ "args.front()" ]
|
|
|
|
INTEGER_COMMAND_VEC_ID:
|
|
template: true
|
|
infer_action: true
|
|
help: ""
|
|
actions:
|
|
GET:
|
|
require_det_id: true
|
|
function: ''
|
|
argc: 0
|
|
output: [ OutString(t) ]
|
|
PUT:
|
|
require_det_id: true
|
|
function: ''
|
|
argc: 1
|
|
input: [ 'args[0]' ]
|
|
cast_input: [ true ]
|
|
input_types: [ int ]
|
|
output: [ 'args.front()' ]
|
|
|
|
INTEGER_COMMAND_VEC_ID_GET:
|
|
template: true
|
|
infer_action: true
|
|
help: ""
|
|
actions:
|
|
GET:
|
|
require_det_id: true
|
|
function: ''
|
|
argc: 0
|
|
output: [ OutString(t) ]
|
|
PUT:
|
|
require_det_id: true
|
|
convert_det_id: false
|
|
function: ''
|
|
argc: 1
|
|
input: [ 'args[0]' ]
|
|
cast_input: [ true ]
|
|
input_types: [ int ]
|
|
output: [ 'args.front()' ]
|
|
|
|
INTEGER_COMMAND_SET_NOID_GET_ID:
|
|
template: true
|
|
infer_action: true
|
|
help: ""
|
|
actions:
|
|
GET:
|
|
require_det_id: true
|
|
function: ''
|
|
argc: 0
|
|
output: [ OutString(t) ]
|
|
PUT:
|
|
check_det_id: true
|
|
function: ''
|
|
argc: 1
|
|
input: [ 'args[0]' ]
|
|
cast_input: [ true ]
|
|
input_types: [ int ]
|
|
output: [ 'args.front()' ]
|
|
|
|
INTEGER_COMMAND_NOID:
|
|
template: true
|
|
infer_action: true
|
|
help: ""
|
|
actions:
|
|
GET:
|
|
check_det_id: true
|
|
function: ''
|
|
argc: 0
|
|
output: [ OutString(t) ]
|
|
PUT:
|
|
check_det_id: true
|
|
function: ''
|
|
argc: 1
|
|
input: [ 'args[0]' ]
|
|
cast_input: [ true ]
|
|
input_types: [ int ]
|
|
output: [ 'args.front()' ]
|
|
|
|
INTEGER_IND_COMMAND:
|
|
template: true
|
|
infer_action: true
|
|
help: ""
|
|
actions:
|
|
GET:
|
|
# extra variable to store the index
|
|
require_det_id: true
|
|
function: ''
|
|
argc: 0
|
|
input: [ 'INDEX' ]
|
|
input_types: [ int ]
|
|
cast_input: [ false ]
|
|
output: [ OutString(t) ]
|
|
PUT:
|
|
# extra variable to store the index
|
|
function: ''
|
|
require_det_id: true
|
|
argc: 1
|
|
input: [ 'INDEX', 'args[0]' ]
|
|
input_types: [ int, int ]
|
|
cast_input: [ false, true ]
|
|
output: [ 'args.front()' ]
|
|
|
|
INTEGER_USER_IND_COMMAND:
|
|
template: true
|
|
infer_action: true
|
|
help: ""
|
|
actions:
|
|
GET:
|
|
# extra variable to store the index
|
|
require_det_id: true
|
|
function: ''
|
|
argc: 1
|
|
input: [ 'INDEX', 'args[0]' ]
|
|
cast_input: [ false, true ]
|
|
input_types: [ int, int ]
|
|
output: [ 'args[0]', "' '", OutStringHex(t) ]
|
|
PUT:
|
|
# extra variable to store the index
|
|
function: ''
|
|
require_det_id: true
|
|
argc: 2
|
|
input: [ 'INDEX', 'args[0]', 'args[1]' ]
|
|
cast_input: [ false, true, true ]
|
|
input_types: [ int, int , int ]
|
|
output: [ 'args[0]', "' '", 'args[1]' ]
|
|
|
|
EXECUTE_SET_COMMAND_NOID:
|
|
template: true
|
|
infer_action: true
|
|
help: ""
|
|
actions:
|
|
PUT:
|
|
check_det_id: true
|
|
function: ''
|
|
output: [ '"successful"' ]
|
|
argc: 0
|
|
|
|
EXECUTE_SET_COMMAND:
|
|
template: true
|
|
infer_action: true
|
|
help: ""
|
|
actions:
|
|
PUT:
|
|
require_det_id: true
|
|
function: ''
|
|
output: [ '"successful"' ]
|
|
argc: 0
|
|
|
|
EXECUTE_SET_COMMAND_NOID_1ARG:
|
|
template: true
|
|
infer_action: true
|
|
help: ""
|
|
actions:
|
|
PUT:
|
|
check_det_id: true
|
|
function: ''
|
|
argc: 1
|
|
input: [ 'args[0]' ]
|
|
cast_input: [ false ]
|
|
arg_types: [special::path]
|
|
input_types: [ std::string ]
|
|
output: [ 'args.front()' ]
|
|
|
|
GET_COMMAND:
|
|
template: true
|
|
infer_action: true
|
|
help: ""
|
|
actions:
|
|
GET:
|
|
require_det_id: true
|
|
function: ''
|
|
argc: 0
|
|
output: [ OutString(t) ]
|
|
|
|
GET_COMMAND_NOID:
|
|
template: true
|
|
infer_action: true
|
|
help: ""
|
|
actions:
|
|
GET:
|
|
function: ''
|
|
argc: 0
|
|
output: [ ToString(t) ]
|
|
|
|
GET_IND_COMMAND:
|
|
template: true
|
|
infer_action: true
|
|
help: ""
|
|
actions:
|
|
GET:
|
|
require_det_id: true
|
|
function: ''
|
|
argc: 0
|
|
input: [ 'VAL' ]
|
|
cast_input: [ false ]
|
|
input_types: [ int ]
|
|
output: [ OutString(t) ]
|
|
|
|
CTB_NAMED_LIST:
|
|
template: true
|
|
infer_action: true
|
|
actions:
|
|
GET:
|
|
extra_variables:
|
|
- name: det_type
|
|
type: auto
|
|
value: det->getDetectorType().squash(defs::GENERIC);
|
|
exceptions:
|
|
- condition: 'cmd != "daclist" && det_type != defs::CHIPTESTBOARD && det_type != defs::XILINX_CHIPTESTBOARD'
|
|
message: 'cmd + " only allowed for CTB."'
|
|
check_det_id: true
|
|
argc: 0
|
|
output: [ 'ToString(t)' ]
|
|
PUT:
|
|
extra_variables:
|
|
- name: det_type
|
|
type: auto
|
|
value: det->getDetectorType().squash(defs::GENERIC);
|
|
exceptions:
|
|
- condition: 'cmd != "daclist" && det_type != defs::CHIPTESTBOARD && det_type != defs::XILINX_CHIPTESTBOARD'
|
|
message: 'cmd + " only allowed for CTB."'
|
|
- condition: 'cmd == "daclist" && det_type != defs::CHIPTESTBOARD && det_type != defs::XILINX_CHIPTESTBOARD'
|
|
message: '"This detector already has fixed dac names. Cannot change them."'
|
|
check_det_id: true
|
|
input: [ 'args' ]
|
|
argc: -1 # unknown number of args
|
|
input_types: [ std::string ]
|
|
output: [ 'ToString(args)' ]
|
|
|
|
CTB_SINGLE_DACNAME:
|
|
template: true
|
|
infer_action: true
|
|
actions:
|
|
GET:
|
|
extra_variables:
|
|
- name: index
|
|
type: defs::dacIndex
|
|
value: 0
|
|
exceptions:
|
|
- condition: 'det->getDetectorType().squash(defs::GENERIC) != defs::CHIPTESTBOARD && det->getDetectorType().squash(defs::GENERIC) != defs::XILINX_CHIPTESTBOARD'
|
|
message: 'cmd + " only allowed for CTB."'
|
|
check_det_id: true
|
|
argc: 1
|
|
input: [ "static_cast<defs::dacIndex>(StringTo<int>(args[0]) + index)" ]
|
|
input_types: [ defs::dacIndex ]
|
|
output: [ 'args[0]',"' '", 't' ]
|
|
|
|
PUT:
|
|
extra_variables:
|
|
- name: index
|
|
type: defs::dacIndex
|
|
value: 0
|
|
exceptions:
|
|
- condition: 'det->getDetectorType().squash(defs::GENERIC) != defs::CHIPTESTBOARD && det->getDetectorType().squash(defs::GENERIC) != defs::XILINX_CHIPTESTBOARD'
|
|
message: 'cmd + " only allowed for CTB."'
|
|
check_det_id: true
|
|
argc: 2
|
|
input: [ "static_cast<defs::dacIndex>(StringTo<int>(args[0]) + index)","args[1]" ]
|
|
input_types: [ defs::dacIndex , std::string ]
|
|
output: [ 'ToString(args)' ]
|
|
|
|
CTB_GET_DACINDEX:
|
|
template: true
|
|
infer_action: true
|
|
actions:
|
|
GET:
|
|
extra_variables:
|
|
- name: index
|
|
type: defs::dacIndex
|
|
value: 0
|
|
|
|
check_det_id: true
|
|
exceptions:
|
|
- condition: 'det->getDetectorType().squash(defs::GENERIC) != defs::CHIPTESTBOARD && det->getDetectorType().squash(defs::GENERIC) != defs::XILINX_CHIPTESTBOARD'
|
|
message: 'cmd + " only allowed for CTB."'
|
|
argc: 1
|
|
input: [ 'args[0]' ]
|
|
input_types: [ std::string ]
|
|
output: [ 'ToString(static_cast<int>(t) - index)' ]
|
|
|
|
CTB_SINGLE_NAME:
|
|
template: true
|
|
infer_action: true
|
|
actions:
|
|
GET:
|
|
check_det_id: true
|
|
exceptions:
|
|
- condition: 'det->getDetectorType().squash(defs::GENERIC) != defs::CHIPTESTBOARD && det->getDetectorType().squash(defs::GENERIC) != defs::XILINX_CHIPTESTBOARD'
|
|
message: 'cmd + " only allowed for CTB."'
|
|
argc: 1
|
|
input: [ "args[0]" ]
|
|
cast_input: [ true ]
|
|
input_types: [ int ]
|
|
output: [ 'args[0]',"' '", 't' ]
|
|
PUT:
|
|
check_det_id: true
|
|
exceptions:
|
|
- condition: 'det->getDetectorType().squash(defs::GENERIC) != defs::CHIPTESTBOARD && det->getDetectorType().squash(defs::GENERIC) != defs::XILINX_CHIPTESTBOARD'
|
|
message: 'cmd + " only allowed for CTB."'
|
|
argc: 2
|
|
cast_input: [ true, false ]
|
|
input: [ "args[0]","args[1]" ]
|
|
input_types: [ int , std::string ]
|
|
output: [ 'ToString(args)' ]
|
|
|
|
CTB_GET_INDEX:
|
|
template: true
|
|
infer_action: true
|
|
actions:
|
|
GET:
|
|
check_det_id: true
|
|
exceptions:
|
|
- condition: 'det->getDetectorType().squash(defs::GENERIC) != defs::CHIPTESTBOARD && det->getDetectorType().squash(defs::GENERIC) != defs::XILINX_CHIPTESTBOARD'
|
|
message: 'cmd + " only allowed for CTB."'
|
|
argc: 1
|
|
input: [ 'args[0]' ]
|
|
input_types: [ std::string ]
|
|
output: [ 'static_cast<int>(t)' ]
|
|
|
|
|
|
################# COMMANDS ##################################
|
|
################# TIME_COMMAND #############
|
|
|
|
period:
|
|
help: "[duration] [(optional unit) ns|us|ms|s]\n\tPeriod between frames"
|
|
inherit_actions: TIME_COMMAND
|
|
actions:
|
|
GET:
|
|
function: getPeriod
|
|
PUT:
|
|
function: setPeriod
|
|
|
|
delay:
|
|
help: "[duration] [(optional unit) ns|us|ms|s]\n\t[Jungfrau][Moench][Gotthard][Mythen3][Gotthard2][Ctb][Moench][Xilinx Ctb] Delay after trigger"
|
|
inherit_actions: TIME_COMMAND
|
|
actions:
|
|
GET:
|
|
function: getDelayAfterTrigger
|
|
PUT:
|
|
function: setDelayAfterTrigger
|
|
|
|
subexptime:
|
|
help: "[duration] [(optional unit) ns|us|ms|s]\n\t[Eiger] Exposure time of EIGER subframes in 32 bit mode."
|
|
inherit_actions: TIME_COMMAND
|
|
actions:
|
|
GET:
|
|
function: getSubExptime
|
|
PUT:
|
|
function: setSubExptime
|
|
|
|
subdeadtime:
|
|
help: "[duration] [(optional unit) ns|us|ms|s]\n\t[Eiger] Dead time of EIGER subframes in 32 bit mode. Subperiod = subexptime + subdeadtime."
|
|
inherit_actions: TIME_COMMAND
|
|
actions:
|
|
GET:
|
|
function: getSubDeadTime
|
|
PUT:
|
|
function: setSubDeadTime
|
|
|
|
compdisabletime:
|
|
help: "[duration] [(optional unit) ns|us|ms|s]\n\t[Jungfrau] Time before end of exposure when comparator is disabled. It is only possible for chipv1.1."
|
|
inherit_actions: TIME_COMMAND
|
|
actions:
|
|
GET:
|
|
function: getComparatorDisableTime
|
|
PUT:
|
|
function: setComparatorDisableTime
|
|
|
|
storagecell_delay:
|
|
help: "[duration (0-1638375 ns)] [(optional unit) ns|us|ms|s]\n\t[Jungfrau] Additional time delay between 2 consecutive exposures in burst mode (resolution of 25ns). Only applicable for chipv1.0. For advanced users only."
|
|
inherit_actions: TIME_COMMAND
|
|
actions:
|
|
GET:
|
|
function: getStorageCellDelay
|
|
PUT:
|
|
function: setStorageCellDelay
|
|
|
|
burstperiod:
|
|
help: "[duration] [(optional unit) ns|us|ms|s]\n\t[Gotthard2] Period between 2 bursts. Only in burst mode and auto timing mode."
|
|
inherit_actions: TIME_COMMAND
|
|
actions:
|
|
GET:
|
|
function: getBurstPeriod
|
|
PUT:
|
|
function: setBurstPeriod
|
|
|
|
################# TIME_GET_COMMAND #############
|
|
delayl:
|
|
help: "\n\t[Gotthard][Jungfrau][Moench][Mythen3][Gotthard2][Ctb][Xilinx Ctb] Delay Left in Acquisition. \n\t[Gotthard2] only in continuous mode."
|
|
inherit_actions: TIME_GET_COMMAND
|
|
actions:
|
|
GET:
|
|
function: getDelayAfterTriggerLeft
|
|
|
|
periodl:
|
|
help: "\n\t[Gotthard][Jungfrau][Moench][Ctb][Mythen3][Gotthard2][Xilinx Ctb] Period left for current frame. \n\t[Gotthard2] only in continuous mode."
|
|
inherit_actions: TIME_GET_COMMAND
|
|
actions:
|
|
GET:
|
|
function: getPeriodLeft
|
|
|
|
measuredperiod:
|
|
help: "[(optional unit) ns|us|ms|s]\n\t[Eiger] Measured frame period between last frame and previous one. Can be measured with minimum 2 frames in an acquisition."
|
|
inherit_actions: TIME_GET_COMMAND
|
|
actions:
|
|
GET:
|
|
function: getMeasuredPeriod
|
|
|
|
measuredsubperiod:
|
|
help: "[(optional unit) ns|us|ms|s]\n\t[Eiger] Measured sub frame period between last sub frame and previous one."
|
|
inherit_actions: TIME_GET_COMMAND
|
|
actions:
|
|
GET:
|
|
function: getMeasuredSubFramePeriod
|
|
|
|
exptimel:
|
|
help: "[(optional unit) ns|us|ms|s]\n\t[Gotthard] Exposure time left for current frame. "
|
|
inherit_actions: TIME_GET_COMMAND
|
|
actions:
|
|
GET:
|
|
function: getExptimeLeft
|
|
|
|
runtime:
|
|
help: "[(optional unit) ns|us|ms|s]\n\t[Jungfrau][Moench][Mythen3][Gotthard2][Ctb][Xilinx Ctb] Time from detector start up.\n\t[Gotthard2] not in burst and auto mode."
|
|
inherit_actions: TIME_GET_COMMAND
|
|
actions:
|
|
GET:
|
|
function: getActualTime
|
|
|
|
frametime:
|
|
help: "[(optional unit) ns|us|ms|s]\n\t[Jungfrau][Moench][Mythen3][Gotthard2][Ctb][Xilinx Ctb] Timestamp at a frame start.\n\t[Gotthard2] not in burst and auto mode."
|
|
inherit_actions: TIME_GET_COMMAND
|
|
actions:
|
|
GET:
|
|
function: getMeasurementTime
|
|
|
|
################# STRING_COMMAND #################
|
|
settingspath:
|
|
help: "[path]\n\t[Eiger][Mythen3] Directory where settings files are loaded from/to."
|
|
inherit_actions: STRING_COMMAND
|
|
actions:
|
|
GET:
|
|
function: getSettingsPath
|
|
PUT:
|
|
function: setSettingsPath
|
|
arg_types: [ special::path ]
|
|
|
|
fpath:
|
|
help: "[path]\n\tDirectory where output data files are written in receiver. Default is '/'. \n\tIf path does not exist and fwrite enabled, it will try to create it at start of acquisition."
|
|
inherit_actions: STRING_COMMAND
|
|
actions:
|
|
GET:
|
|
function: getFilePath
|
|
PUT:
|
|
function: setFilePath
|
|
arg_types: [ special::path ]
|
|
|
|
fname:
|
|
help: "[name]\n\tFile name prefix for output data file. Default is run. File name: [file name prefix]_d[detector index]_f[sub file index]_[acquisition/file index].raw."
|
|
inherit_actions: STRING_COMMAND
|
|
actions:
|
|
GET:
|
|
function: getFileNamePrefix
|
|
PUT:
|
|
function: setFileNamePrefix
|
|
|
|
################# INTEGER_COMMAND_HEX_WIDTH16 #################
|
|
patioctrl:
|
|
help: "[64 bit mask]\n\t[Ctb] 64 bit mask defining input (0) and output (1) signals."
|
|
inherit_actions: INTEGER_COMMAND_HEX_WIDTH16
|
|
actions:
|
|
GET:
|
|
function: getPatternIOControl
|
|
PUT:
|
|
function: setPatternIOControl
|
|
|
|
patmask:
|
|
help: "[64 bit mask]\n\t[Ctb][Mythen3][Xilinx Ctb] Selects the bits that will have a pattern mask applied to the selected patmask for every pattern."
|
|
inherit_actions: INTEGER_COMMAND_HEX_WIDTH16
|
|
actions:
|
|
GET:
|
|
function: getPatternMask
|
|
PUT:
|
|
function: setPatternMask
|
|
|
|
patsetbit:
|
|
help: "[64 bit mask]\n\t[Ctb][Mythen3][Xilinx Ctb] Sets the mask applied to every pattern to the selected bits."
|
|
inherit_actions: INTEGER_COMMAND_HEX_WIDTH16
|
|
actions:
|
|
GET:
|
|
function: getPatternBitMask
|
|
PUT:
|
|
function: setPatternBitMask
|
|
|
|
################# INTEGER_COMMAND_HEX #################
|
|
adcenable:
|
|
help: "[bitmask]\n\t[Ctb] ADC Enable Mask for 1Gb Enable for each 32 ADC channel."
|
|
inherit_actions: INTEGER_COMMAND_HEX
|
|
actions:
|
|
GET:
|
|
function: getADCEnableMask
|
|
PUT:
|
|
function: setADCEnableMask
|
|
|
|
adcenable10g:
|
|
help: "[bitmask]\n\t[Ctb] ADC Enable Mask for 10Gb mode for each 32 ADC channel. However, if any of a consecutive 4 bits are enabled, the complete 4 bits are enabled."
|
|
inherit_actions: INTEGER_COMMAND_HEX
|
|
actions:
|
|
GET:
|
|
function: getTenGigaADCEnableMask
|
|
PUT:
|
|
function: setTenGigaADCEnableMask
|
|
|
|
transceiverenable:
|
|
help: "[bitmask]\n\t[Ctb][Xilinx Ctb] Transceiver Enable Mask. Enable for each 4 Transceiver channel."
|
|
inherit_actions: INTEGER_COMMAND_HEX
|
|
actions:
|
|
GET:
|
|
function: getTransceiverEnableMask
|
|
PUT:
|
|
function: setTransceiverEnableMask
|
|
|
|
adcinvert:
|
|
help: "[bitmask]\n\t[Ctb][Jungfrau][Moench] ADC Inversion Mask.\n\t[Jungfrau][Moench] Inversions on top of the default mask."
|
|
inherit_actions: INTEGER_COMMAND_HEX
|
|
actions:
|
|
GET:
|
|
function: getADCInvert
|
|
PUT:
|
|
function: setADCInvert
|
|
|
|
################# INTEGER_COMMAND_VEC_ID #################
|
|
settings:
|
|
help: "[standard, fast, highgain, dynamicgain, lowgain, mediumgain, veryhighgain, highgain0, fixgain1, fixgain2, forceswitchg1, forceswitchg2, verylowgain, g1_hg, g1_lg, g2_hc_hg, g2_hc_lg, g2_lc_hg, g2_lc_lg, g4_hg, g4_lg, gain0]\n\t Detector Settings\n\t[Jungfrau] - [ gain0 | highgain0]\n\t[Gotthard] - [dynamicgain | highgain | lowgain | mediumgain | veryhighgain]\n\t[Gotthard] Also loads default dacs on to the detector.\n\t[Gotthard2] - [dynamicgain | fixgain1 | fixgain2]\n\t[Mythen3] - [standard | fast | highgain] Also changes vrshaper and vrpreamp. \n\t[Eiger] Use threshold or thresholdnotb. \n\t[Eiger] threshold and settings loaded from file found in settingspath. \n\t[Moench] - [g1_hg | g1_lg | g2_hc_hg | g2_hc_lg | g2_lc_hg | g2_lc_lg | g4_hg | g4_lg]"
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getSettings
|
|
PUT:
|
|
function: setSettings
|
|
input_types: [ defs::detectorSettings ]
|
|
|
|
trimval:
|
|
help: "[n_trimval]\n\t[Eiger][Mythen3] All trimbits set to this value. Returns -1 if all trimbits are different values."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getAllTrimbits
|
|
PUT:
|
|
function: setAllTrimbits
|
|
|
|
fliprows:
|
|
help: "[0, 1]\n\t[Eiger] flips rows paramater sent to slsreceiver to stream as json parameter to flip rows in gui \n\t[Jungfrau][Moench] flips rows in the detector itself. For bottom module and number of interfaces must be set to 2. slsReceiver and slsDetectorGui does not handle."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getFlipRows
|
|
PUT:
|
|
function: setFlipRows
|
|
input_types: [ bool ]
|
|
|
|
row:
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
help: "[value]\n\tSet Detector row (udp header) to value. \n\tGui uses it to rearrange for complete image"
|
|
actions:
|
|
GET:
|
|
function: getRow
|
|
PUT:
|
|
function: setRow
|
|
|
|
column:
|
|
help: "[value]\n\tSet Detector column (udp header) to value. \n\tGui uses it to rearrange for complete image"
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getColumn
|
|
PUT:
|
|
function: setColumn
|
|
|
|
timing:
|
|
help: "[auto|trigger|gating|burst_trigger|trigger_gating]\n\tTiming Mode of detector.\n\t[Jungfrau][Moench][Gotthard][Ctb][Gotthard2][Xilinx Ctb] [auto|trigger]\n\t[Mythen3] [auto|trigger|gating|trigger_gating]\n\t[Eiger] [auto|trigger|gating|burst_trigger]"
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getTimingMode
|
|
PUT:
|
|
function: setTimingMode
|
|
input_types: [ defs::timingMode ]
|
|
|
|
highvoltage:
|
|
help: "[n_value]\n\tHigh voltage to the sensor in Voltage. \n\t[Gotthard] [0|90|110|120|150|180|200] \n\t[Eiger][Mythen3][Gotthard2] 0-200 \n\t[Jungfrau][Moench][Ctb] [0|60-200]"
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getHighVoltage
|
|
PUT:
|
|
function: setHighVoltage
|
|
|
|
powerchip:
|
|
help: "[0, 1]\n\t[Jungfrau][Moench][Mythen3][Gotthard2][Xilinx Ctb] Power the chip. \n\t[Jungfrau][Moench] Default is 0. Get will return power status. Can be off if temperature event occured (temperature over temp_threshold with temp_control enabled. Will configure chip (only chip v1.1)\n\t[Mythen3][Gotthard2] Default is 1. If module not connected or wrong module, powerchip will fail.\n\t[Xilinx Ctb] Default is 0. Also configures the chip if powered on."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getPowerChip
|
|
PUT:
|
|
function: setPowerChip
|
|
input_types: [ bool ]
|
|
|
|
imagetest:
|
|
help: "[0, 1]\n\t[Gotthard] 1 adds channel intensity with precalculated values when taking an acquisition. Default is 0.\n\t[Eiger][Jungfrau][Moench] Only for Virtual servers. If 0, each pixel intensity incremented by 1. If 1, all pixels almost saturated."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getImageTestMode
|
|
PUT:
|
|
function: setImageTestMode
|
|
input_types: [ bool ]
|
|
|
|
parallel:
|
|
help: "[0, 1]\n\t[Eiger][Mythen3][Gotthard2][Moench] Enable or disable parallel mode.\n\t[Mythen3] If exptime is too short, the acquisition will return ERROR status and take fewer frames than expected.\n\t[Mythen3][Eiger][Moench] Default: Non parallel.\n\t[Gotthard2] Default: Parallel. Non parallel mode works only in continuous mode."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getParallelMode
|
|
PUT:
|
|
function: setParallelMode
|
|
input_types: [ bool ]
|
|
|
|
filterresistor:
|
|
help: "[value] [Gotthard2][Jungfrau] Set filter resistor. Increasing values for increasing resistance.\n\t[Gotthard2] Options: [0|1|2|3]. Default is 0.\n\t[Jungfrau] Options: [0|1]. Default is 1."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getFilterResistor
|
|
PUT:
|
|
function: setFilterResistor
|
|
|
|
dbitpipeline:
|
|
help: "[n_value]\n\t[Ctb][Gotthard2] Pipeline of the clock for latching digital bits.\n\t[Gotthard2] Options: 0-7\n\t[Ctb] Options: 0-255"
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getDBITPipeline
|
|
PUT:
|
|
function: setDBITPipeline
|
|
|
|
readnrows:
|
|
help: "\n\t[1-256]\n\t\t[Eiger] Number of rows to readout per half module starting from the centre. Options: 0 - 256. 256 is default. The permissible values depend on dynamic range and 10Gbe enabled.\n\t[8-512 (multiple of 8)]\n\t\t[Jungfrau] Number of rows per module starting from the centre. Options: 8 - 512, must be multiples of 8. Default is 512.\n\t\t[Moench] Number of rows per module starting from the centre. Options:16 - 400, must be multiples of 16. Default is 400."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getReadNRows
|
|
PUT:
|
|
function: setReadNRows
|
|
|
|
nextframenumber:
|
|
help: "[n_value]\n\t[Eiger][Jungfrau][Moench][Ctb][Xilinx Ctb][Gotthard2] Next frame number. Stopping acquisition might result in different frame numbers for different modules. So, after stopping, next frame number (max + 1) is set for all the modules afterwards."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getNextFrameNumber
|
|
PUT:
|
|
function: setNextFrameNumber
|
|
input_types: [ uint64_t ]
|
|
|
|
numinterfaces:
|
|
help: "[1, 2]\n\t[Jungfrau][Moench] Number of udp interfaces to stream data from detector. Default: 1.\n\tAlso enables second interface in receiver for listening (Writes a file per interface if writing enabled).\n\tAlso restarts client and receiver zmq sockets if zmq streaming enabled.\n\t[Eiger] Only gets with result 2."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getNumberofUDPInterfaces
|
|
PUT:
|
|
function: setNumberofUDPInterfaces
|
|
|
|
selinterface:
|
|
help: "[0, 1]\n\t[Jungfrau][Moench] The udp interface to stream data from detector. Effective only when number of interfaces is 1. Default: 0 (outer)"
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getSelectedUDPInterface
|
|
PUT:
|
|
function: selectUDPInterface
|
|
input_types: [ bool ]
|
|
|
|
udp_firstdst:
|
|
help: "\n\t[0 - N]\n\twhere N is the max number of udp destinations - 1.\n\t[Jungfrau][Moench][Gotthard2] Max number of udp destinations is 32.\n\t[Mythen3] Max number of udp destination is 64.\n\t One can set which is the first destination that the detector will stream images out from in a round robin fashion. The entry must not have been empty. Default: 0"
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getFirstUDPDestination
|
|
PUT:
|
|
function: setFirstUDPDestination
|
|
|
|
udp_srcmac:
|
|
help: "[x:x:x:x:x:x]\n\tMac address of the detector (source) udp interface. \n\t[Eiger] Do not set as detector will replace with its own DHCP Mac (1G) or DHCP Mac + 1 (10G)."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getSourceUDPMAC
|
|
PUT:
|
|
function: setSourceUDPMAC
|
|
input_types: [ MacAddr ]
|
|
input: [ 'MacAddr(args[0])' ]
|
|
cast_input: [ false ]
|
|
|
|
udp_srcmac2:
|
|
help: "[x:x:x:x:x:x]\n\t[Jungfrau][Moench] Mac address of the top half or inner (source) udp interface. "
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getSourceUDPMAC2
|
|
PUT:
|
|
function: setSourceUDPMAC2
|
|
input_types: [ MacAddr ]
|
|
input: [ 'MacAddr(args[0])' ]
|
|
cast_input: [ false ]
|
|
|
|
udp_dstmac:
|
|
help: "[x:x:x:x:x:x]\n\tMac address of the receiver (destination) udp interface. Not mandatory to set as udp_dstip retrieves it from slsReceiver process, but must be set if you use a custom receiver (not slsReceiver). Use router mac if router between detector and receiver."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getDestinationUDPMAC
|
|
PUT:
|
|
function: setDestinationUDPMAC
|
|
input_types: [ MacAddr ]
|
|
input: [ 'MacAddr(args[0])' ]
|
|
cast_input: [ false ]
|
|
|
|
udp_dstmac2:
|
|
help: "[x:x:x:x:x:x]\n\t[Jungfrau][Moench] Mac address of the receiver (destination) udp interface 2. Not mandatory to set as udp_dstip2 retrieves it from slsReceiver process but must be set if you use a custom receiver (not slsReceiver). \n\t [Jungfrau][Moench] top half or inner interface \n\t [Gotthard2] veto debugging. Use router mac if router between detector and receiver."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getDestinationUDPMAC2
|
|
PUT:
|
|
function: setDestinationUDPMAC2
|
|
input_types: [ MacAddr ]
|
|
input: [ 'MacAddr(args[0])' ]
|
|
cast_input: [ false ]
|
|
|
|
tengiga:
|
|
help: "[0, 1]\n\t[Eiger][Ctb][Mythen3] 10GbE Enable."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getTenGiga
|
|
PUT:
|
|
function: setTenGiga
|
|
input_types: [ bool ]
|
|
|
|
flowcontrol10g:
|
|
help: "[0, 1]\n\t[Eiger][Jungfrau][Moench] 10GbE Flow Control."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getTenGigaFlowControl
|
|
PUT:
|
|
function: setTenGigaFlowControl
|
|
input_types: [ bool ]
|
|
|
|
txdelay_frame:
|
|
help: "[n_delay]\n\t[Eiger][Jungfrau][Moench][Mythen3] Transmission delay of first udp packet being streamed out of the module.\n\t[Jungfrau][Moench] [0-31] Each value represents 1 ms\n\t[Eiger] Additional delay to txdelay_left and txdelay_right. Each value represents 10ns. Typical value is 50000.\n\t[Mythen3] [0-16777215] Each value represents 8 ns (125 MHz clock), max is 134 ms."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getTransmissionDelayFrame
|
|
PUT:
|
|
function: setTransmissionDelayFrame
|
|
|
|
txdelay_left:
|
|
help: "[n_delay]\n\t[Eiger] Transmission delay of first packet in an image being streamed out of the module's left UDP port. Each value represents 10ns. Typical value is 50000."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getTransmissionDelayLeft
|
|
PUT:
|
|
function: setTransmissionDelayLeft
|
|
|
|
txdelay_right:
|
|
help: "[n_delay]\n\t[Eiger] Transmission delay of first packet in an image being streamed out of the module's right UDP port. Each value represents 10ns. Typical value is 50000."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getTransmissionDelayRight
|
|
PUT:
|
|
function: setTransmissionDelayRight
|
|
|
|
rx_fifodepth:
|
|
help: "[n_frames]\n\tSet the number of frames in the receiver fifo depth (buffer between listener and writer threads)."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getRxFifoDepth
|
|
PUT:
|
|
function: setRxFifoDepth
|
|
|
|
rx_silent:
|
|
help: "[0, 1]\n\tSwitch on or off receiver text output during acquisition."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getRxSilentMode
|
|
PUT:
|
|
function: setRxSilentMode
|
|
input_types: [ bool ]
|
|
|
|
rx_discardpolicy:
|
|
help: "[nodiscard (default)|discardempty|discardpartial(fastest)]\n\tFrame discard policy of receiver. nodiscard does not discard frames, discardempty discards empty frames, discardpartial discards partial frames."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getRxFrameDiscardPolicy
|
|
PUT:
|
|
function: setRxFrameDiscardPolicy
|
|
input_types: [ defs::frameDiscardPolicy ]
|
|
|
|
rx_padding:
|
|
help: "[0, 1]\n\tPartial frames padding enable in the receiver. Default: enabled. Disabling is fastest."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getPartialFramesPadding
|
|
PUT:
|
|
function: setPartialFramesPadding
|
|
input_types: [ bool ]
|
|
|
|
rx_udpsocksize:
|
|
help: "[n_size]\n\tUDP socket buffer size in receiver. Tune rmem_default and rmem_max accordingly. Max value is INT_MAX/2."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getRxUDPSocketBufferSize
|
|
PUT:
|
|
function: setRxUDPSocketBufferSize
|
|
|
|
rx_lock:
|
|
help: "[0, 1]\n\tLock receiver to one client IP, 1 locks, 0 unlocks. Default is unlocked."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getRxLock
|
|
PUT:
|
|
function: setRxLock
|
|
input_types: [ bool ]
|
|
|
|
rx_arping:
|
|
help: "[0, 1]\n\tStarts a thread in slsReceiver to arping the interface it is listening to every minute. Useful in 10G mode."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getRxArping
|
|
PUT:
|
|
function: setRxArping
|
|
input_types: [ bool ]
|
|
|
|
fformat:
|
|
help: "[binary|hdf5]\n\tFile format of data file. For HDF5, package must be compiled with HDF5 flags. Default is binary."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getFileFormat
|
|
PUT:
|
|
function: setFileFormat
|
|
input_types: [ defs::fileFormat ]
|
|
|
|
findex:
|
|
help: "[n_value]\n\tFile or Acquisition index."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getAcquisitionIndex
|
|
PUT:
|
|
function: setAcquisitionIndex
|
|
input_types: [ uint64_t ]
|
|
|
|
fwrite:
|
|
help: "[0, 1]\n\tEnable or disable receiver file write. Default is 0."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getFileWrite
|
|
PUT:
|
|
function: setFileWrite
|
|
input_types: [ bool ]
|
|
|
|
foverwrite:
|
|
help: "[0, 1]\n\tEnable or disable file overwriting. Default is 1."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getFileOverWrite
|
|
PUT:
|
|
function: setFileOverWrite
|
|
input_types: [ bool ]
|
|
|
|
rx_framesperfile:
|
|
help: "[n_frames]\n\tNumber of frames per file in receiver in an acquisition. Default depends on detector type. 0 is infinite or all frames in single file."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getFramesPerFile
|
|
PUT:
|
|
function: setFramesPerFile
|
|
|
|
rx_zmqstream:
|
|
help: "[0, 1]\n\tEnable/ disable data streaming from receiver via zmq (eg. to GUI or to another process for further processing). This creates/ destroys zmq streamer threads in receiver. \n\tSwitching to Gui automatically enables data streaming in receiver. \n\tSwitching back to command line acquire will require disabling data streaming in receiver for fast applications. "
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getRxZmqDataStream
|
|
PUT:
|
|
function: setRxZmqDataStream
|
|
input_types: [ bool ]
|
|
|
|
rx_zmqfreq:
|
|
help: "[nth frame]\n\tFrequency of frames streamed out from receiver via zmq\n\tDefault: 1, Means every frame is streamed out. \n\tIf 2, every second frame is streamed out. \n\tIf 0, streaming timer is the timeout, after which current frame is sent out. (default timeout is 500 ms). Usually used for gui purposes."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getRxZmqFrequency
|
|
PUT:
|
|
function: setRxZmqFrequency
|
|
|
|
rx_zmqstartfnum:
|
|
help: "[fnum]\n\tThe starting frame index to stream out. 0 by default, which streams the first frame in an acquisition, and then depending on the rx zmq frequency/ timer"
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getRxZmqStartingFrame
|
|
PUT:
|
|
function: setRxZmqStartingFrame
|
|
|
|
zmqip:
|
|
help: "[x.x.x.x]\n\tIp Address to listen to zmq data streamed out from receiver or intermediate process. Default connects to receiver zmq Ip Address (from rx_hostname). Modified only when using an intermediate process between receiver and client(gui). Also restarts client zmq streaming if enabled."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getClientZmqIp
|
|
PUT:
|
|
function: setClientZmqIp
|
|
input_types: [ IpAddr ]
|
|
input: [ 'IpAddr(args[0])' ]
|
|
cast_input: [ false ]
|
|
|
|
overflow:
|
|
help: "[0, 1]\n\t[Eiger] Enable or disable show overflow flag in 32 bit mode. Default is disabled."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getOverFlowMode
|
|
PUT:
|
|
function: setOverFlowMode
|
|
input_types: [ bool ]
|
|
|
|
interruptsubframe:
|
|
help: "[0, 1]\n\t[Eiger] 1 interrupts last subframe at required exposure time. 0 will wait for last sub frame to finish exposing. 0 is default."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getInterruptSubframe
|
|
PUT:
|
|
function: setInterruptSubframe
|
|
input_types: [ bool ]
|
|
|
|
activate:
|
|
help: "[0, 1]\n\t[Eiger] 1 is default. 0 deactivates readout and does not send data."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getActive
|
|
PUT:
|
|
function: setActive
|
|
input_types: [ bool ]
|
|
|
|
partialreset:
|
|
help: "[0, 1]\n\t[Eiger] Sets up detector to do partial or complete reset at start of acquisition. 0 complete reset, 1 partial reset. Default is complete reset. Advanced function!"
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getPartialReset
|
|
PUT:
|
|
function: setPartialReset
|
|
input_types: [ bool ]
|
|
|
|
top:
|
|
help: "[0, 1]\n\t[Eiger] Sets half module to top (1), else bottom."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getTop
|
|
PUT:
|
|
function: setTop
|
|
input_types: [ bool ]
|
|
|
|
temp_threshold:
|
|
help: "[n_temp (in degrees)]\n\t[Jungfrau][Moench] Threshold temperature in degrees. If temperature crosses threshold temperature and temperature control is enabled, power to chip will be switched off and temperature event occurs. To power on chip again, temperature has to be less than threshold temperature and temperature event has to be cleared."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getThresholdTemperature
|
|
PUT:
|
|
function: setThresholdTemperature
|
|
|
|
temp_control:
|
|
help: "[0, 1]\n\t[Jungfrau][Moench] Temperature control enable. Default is 0 (disabled). If temperature crosses threshold temperature and temperature control is enabled, power to chip will be switched off and temperature event occurs. To power on chip again, temperature has to be less than threshold temperature and temperature event has to be cleared."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getTemperatureControl
|
|
PUT:
|
|
function: setTemperatureControl
|
|
input_types: [ bool ]
|
|
|
|
autocompdisable:
|
|
help: "[0, 1]\n\t[Jungfrau] Auto comparator disable mode. By default, the on-chip gain switching is active during the entire exposure.This mode disables the on - chip gain switching comparator automatically after 93.75% (only for chipv1.0) of exposure time (only for longer than 100us). It is possible to set the duration for chipv1.1 using compdisabletime command.\n\tDefault is 0 or this mode disabled(comparator enabled throughout). 1 enables mode. 0 disables mode. "
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getAutoComparatorDisable
|
|
PUT:
|
|
function: setAutoComparatorDisable
|
|
input_types: [ bool ]
|
|
|
|
storagecell_start:
|
|
help: "[0-max]\n\t[Jungfrau] Storage cell that stores the first acquisition of the series. max is 15 (default) for chipv1.0 and 3 (default) for chipv1.1. For advanced users only."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getStorageCellStart
|
|
PUT:
|
|
function: setStorageCellStart
|
|
|
|
gainmode:
|
|
help: "[dynamic|forceswitchg1|forceswitchg2|fixg1|fixg2|fixg0]\n\t[Jungfrau] Gain mode.\n\tCAUTION: Do not use fixg0 without caution, you can damage the detector!!!"
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getGainMode
|
|
PUT:
|
|
function: setGainMode
|
|
input_types: [ defs::gainMode ]
|
|
|
|
filtercells:
|
|
help: "[0-12]\n\t[Jungfrau] Set Filter Cell. Only for chipv1.1. Advanced user Command"
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getNumberOfFilterCells
|
|
PUT:
|
|
function: setNumberOfFilterCells
|
|
|
|
cdsgain:
|
|
help: "[0, 1]\n\t[Gotthard2] Enable or disable CDS gain. Default is disabled."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getCDSGain
|
|
PUT:
|
|
function: setCDSGain
|
|
input_types: [ bool ]
|
|
|
|
timingsource:
|
|
help: "[internal|external]\n\t[Gotthard2] Timing source. Internal is crystal and external is system timing. Default is internal."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getTimingSource
|
|
PUT:
|
|
function: setTimingSource
|
|
input_types: [ defs::timingSourceType ]
|
|
|
|
veto:
|
|
help: "[0, 1]\n\t[Gotthard2] Enable or disable veto data data from chip. Default is 0."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getVeto
|
|
PUT:
|
|
function: setVeto
|
|
input_types: [ bool ]
|
|
|
|
gates:
|
|
help: "[n_gates]\n\t[Mythen3] Number of external gates in gating or trigger_gating mode (external gating)."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getNumberOfGates
|
|
PUT:
|
|
function: setNumberOfGates
|
|
|
|
polarity:
|
|
help: "[pos|neg]\n\t[Mythen3] Sets negative or positive polarity. Default is positive"
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getPolarity
|
|
PUT:
|
|
function: setPolarity
|
|
input_types: [ defs::polarity ]
|
|
|
|
timing_info_decoder:
|
|
help: "[swissfel|shine]\n\t[Jungfrau] Advanced Command and only for Swissfel and Shine. Sets the bunch id or timing info decoder. Default is swissfel."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getTimingInfoDecoder
|
|
PUT:
|
|
function: setTimingInfoDecoder
|
|
input_types: [ defs::timingInfoDecoder ]
|
|
|
|
collectionmode:
|
|
help: "[hole|electron]\n\t[Jungfrau] Sets collection mode to hole or electron. Default is hole."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getCollectionMode
|
|
PUT:
|
|
function: setCollectionMode
|
|
input_types: [ defs::collectionMode ]
|
|
|
|
interpolation:
|
|
help: "[0, 1]\n\t[Mythen3] Enables or disables interpolation. Default is disabled. Interpolation mode enables all counters and disables vth3. Disabling sets back counter mask and vth3."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getInterpolation
|
|
PUT:
|
|
function: setInterpolation
|
|
input_types: [ bool ]
|
|
|
|
pumpprobe:
|
|
help: "[0, 1]\n\t[Mythen3] Enables or disables pump probe mode. Default is disabled. Pump probe mode only enables vth2. Disabling sets back to previous value."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getPumpProbe
|
|
PUT:
|
|
function: setPumpProbe
|
|
input_types: [ bool ]
|
|
|
|
apulse:
|
|
help: "[0, 1]\n\t[Mythen3] Enables or disables analog pulsing. Default is disabled"
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getAnalogPulsing
|
|
PUT:
|
|
function: setAnalogPulsing
|
|
input_types: [ bool ]
|
|
|
|
dpulse:
|
|
help: "[0, 1]\n\t[Mythen3] Enables or disables digital pulsing. Default is disabled"
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getDigitalPulsing
|
|
PUT:
|
|
function: setDigitalPulsing
|
|
input_types: [ bool ]
|
|
|
|
asamples:
|
|
help: "[n_samples]\n\t[Ctb] Number of analog samples expected."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getNumberOfAnalogSamples
|
|
PUT:
|
|
function: setNumberOfAnalogSamples
|
|
|
|
adcclk:
|
|
help: "[n_clk in MHz]\n\t[Ctb] ADC clock frequency in MHz."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getADCClock
|
|
PUT:
|
|
function: setADCClock
|
|
|
|
runclk:
|
|
help: "[n_clk in MHz]\n\t[Ctb] Run clock in MHz."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getRUNClock
|
|
PUT:
|
|
function: setRUNClock
|
|
|
|
dsamples:
|
|
help: "[n_value]\n\t[Ctb] Number of digital samples expected."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getNumberOfDigitalSamples
|
|
PUT:
|
|
function: setNumberOfDigitalSamples
|
|
|
|
tsamples:
|
|
help: "[n_value]\n\t[Ctb][Xilinx Ctb] Number of transceiver samples expected."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getNumberOfTransceiverSamples
|
|
PUT:
|
|
function: setNumberOfTransceiverSamples
|
|
|
|
romode:
|
|
help: "[analog|digital|analog_digital|transceiver|digital_transceiver]\n\t[Ctb][xilinx Ctb] Readout mode. [Ctb] Default is analog. [Xilinx Ctb] Default is Transceiver (only one implemented so far)"
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getReadoutMode
|
|
PUT:
|
|
function: setReadoutMode
|
|
input_types: [ defs::readoutMode ]
|
|
|
|
dbitclk:
|
|
help: "[n_clk in MHz]\n\t[Ctb] Clock for latching the digital bits in MHz."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getDBITClock
|
|
PUT:
|
|
function: setDBITClock
|
|
|
|
extsampling:
|
|
help: "[0, 1]\n\t[Ctb] Enable for external sampling signal for digital data to signal by extsampling src command. For advanced users only."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getExternalSampling
|
|
PUT:
|
|
function: setExternalSampling
|
|
input_types: [ bool ]
|
|
|
|
extsamplingsrc:
|
|
help: "[0-63]\n\t[Ctb] Sampling source signal for digital data. For advanced users only."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getExternalSamplingSource
|
|
PUT:
|
|
function: setExternalSamplingSource
|
|
|
|
rx_dbitoffset:
|
|
help: "[n_bytes]\n\t[Ctb] Offset in bytes in digital data to skip in receiver."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getRxDbitOffset
|
|
PUT:
|
|
function: setRxDbitOffset
|
|
|
|
led:
|
|
help: "[0, 1]\n\t[Ctb] Switches on/off all LEDs."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getLEDEnable
|
|
PUT:
|
|
function: setLEDEnable
|
|
input_types: [ bool ]
|
|
|
|
adcpipeline:
|
|
help: "[n_value]\n\t[Ctb][Moench] Pipeline for ADC clock."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getADCPipeline
|
|
PUT:
|
|
function: setADCPipeline
|
|
|
|
updatemode:
|
|
help: "[0|1]\n\tRestart the detector server in update mode or not. This is useful when server-firmware compatibility is at its worst and server cannot start up normally"
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getUpdateMode
|
|
PUT:
|
|
function: setUpdateMode
|
|
|
|
port:
|
|
help: "[n]\n\tPort number of the control server on detector for detector-client tcp interface. Default is 1952. Normally unchanged. Set different ports for virtual servers on same pc."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getControlPort
|
|
PUT:
|
|
input_types: [ uint16_t ]
|
|
function: setControlPort
|
|
|
|
stopport:
|
|
help: "[n]\n\tPort number of the stop server on detector for detector-client tcp interface. Default is 1953. Normally unchanged."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getStopPort
|
|
PUT:
|
|
input_types: [ uint16_t ]
|
|
function: setStopPort
|
|
|
|
lock:
|
|
help: "[0, 1]\n\tLock detector to one IP, 1: locks. Default is unlocked"
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID
|
|
actions:
|
|
GET:
|
|
function: getDetectorLock
|
|
PUT:
|
|
function: setDetectorLock
|
|
input_types: [ bool ]
|
|
|
|
################# INTEGER_COMMAND_VEC_ID_GET #################
|
|
|
|
master:
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID_GET
|
|
help: "[0, 1]\n\t[Eiger][Gotthard2][Jungfrau][Moench] Sets (half) module to master and other(s) to slaves.\n\t[Gotthard][Gotthard2][Mythen3][Eiger][Jungfrau][Moench] Gets if the current (half) module is master."
|
|
actions:
|
|
GET:
|
|
function: getMaster
|
|
PUT:
|
|
function: setMaster
|
|
input_types: [ bool ]
|
|
|
|
udp_dstport:
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID_GET
|
|
help: "[n]\n\tPort number of the receiver (destination) udp interface. Default is 50001. \n\tIf multi command, ports for each module is calculated (incremented by 1 if no 2nd interface)"
|
|
actions:
|
|
GET:
|
|
function: getDestinationUDPPort
|
|
PUT:
|
|
input_types: [ uint16_t ]
|
|
function: setDestinationUDPPort
|
|
|
|
udp_dstport2:
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID_GET
|
|
help: "[n]\n\t[Jungfrau][Moench][Eiger][Gotthard2] Port number of the receiver (destination) udp interface 2. Default is 50002. \n\tIf multi command, ports for each module is calculated (incremented by 2) \n\t[Jungfrau][Moench] top half or inner interface \n\t[Eiger] right half \n\t[Gotthard2] veto debugging"
|
|
actions:
|
|
GET:
|
|
function: getDestinationUDPPort2
|
|
PUT:
|
|
input_types: [ uint16_t ]
|
|
function: setDestinationUDPPort2
|
|
|
|
rx_tcpport:
|
|
help: "[port]\n\tTCP port for client-receiver communication. Default is 1954. Must be different if multiple receivers on same pc. Must be first command to set a receiver parameter. Multi command will automatically increment for individual modules."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID_GET
|
|
actions:
|
|
GET:
|
|
function: getRxPort
|
|
PUT:
|
|
input_types: [ uint16_t ]
|
|
function: setRxPort
|
|
|
|
rx_zmqport:
|
|
help: "[port]\n\tZmq port for data to be streamed out of the receiver. Also restarts receiver zmq streaming if enabled. Default is 30001. Modified only when using an intermediate process between receiver and client(gui). Must be different for every detector (and udp port). Multi command will automatically increment for individual modules."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID_GET
|
|
actions:
|
|
GET:
|
|
function: getRxZmqPort
|
|
PUT:
|
|
input_types: [ uint16_t ]
|
|
function: setRxZmqPort
|
|
|
|
zmqport:
|
|
help: "[port]\n\tZmq port in client(gui) or intermediate process for data to be streamed to from receiver. Default connects to receiver zmq streaming out port (30001). Modified only when using an intermediate process between receiver and client(gui). Also restarts client zmq streaming if enabled. Must be different for every detector (and udp port). Multi command will automatically increment for individual modules."
|
|
inherit_actions: INTEGER_COMMAND_VEC_ID_GET
|
|
actions:
|
|
GET:
|
|
function: getClientZmqPort
|
|
PUT:
|
|
input_types: [ uint16_t ]
|
|
function: setClientZmqPort
|
|
|
|
################# INTEGER_COMMAND_SET_NOID_GET_ID ############
|
|
sync:
|
|
inherit_actions: INTEGER_COMMAND_SET_NOID_GET_ID
|
|
help: "[0, 1]\n\t[Jungfrau][Moench] Enables or disables synchronization between modules. Sync mode requires at least one master configured. Also requires flatband cabling between master and slave with termination board."
|
|
actions:
|
|
GET:
|
|
function: getSynchronization
|
|
PUT:
|
|
function: setSynchronization
|
|
input_types: [ bool ]
|
|
|
|
frames:
|
|
inherit_actions: INTEGER_COMMAND_SET_NOID_GET_ID
|
|
help: "[n_frames]\n\tNumber of frames per acquisition. In trigger mode, number of frames per trigger. \n\tCannot be set in modular level. \n\tIn scan mode, number of frames is set to number of steps.\n\t[Gotthard2] Burst mode has a maximum of 2720 frames."
|
|
actions:
|
|
GET:
|
|
function: getNumberOfFrames
|
|
PUT:
|
|
function: setNumberOfFrames
|
|
input_types: [ int64_t ]
|
|
|
|
triggers:
|
|
inherit_actions: INTEGER_COMMAND_SET_NOID_GET_ID
|
|
help: "[n_triggers]\n\tNumber of triggers per aquire. Set timing mode to use triggers."
|
|
actions:
|
|
GET:
|
|
function: getNumberOfTriggers
|
|
PUT:
|
|
function: setNumberOfTriggers
|
|
input_types: [ int64_t ]
|
|
|
|
dr:
|
|
inherit_actions: INTEGER_COMMAND_SET_NOID_GET_ID
|
|
help: "[value]\n\tDynamic Range or number of bits per pixel in detector.\n\t[Eiger] Options: 4, 8, 12, 16, 32. If set to 32, also sets clkdivider to 2, else to 0.\n\t[Mythen3] Options: 8, 16, 32\n\t[Jungfrau][Moench][Gotthard][Ctb][Mythen3][Gotthard2][Xilinx Ctb] 16"
|
|
actions:
|
|
GET:
|
|
function: getDynamicRange
|
|
PUT:
|
|
function: setDynamicRange
|
|
|
|
rx_zmqhwm:
|
|
inherit_actions: INTEGER_COMMAND_SET_NOID_GET_ID
|
|
help: "[n_value]\n\tReceiver's zmq send high water mark. Default is the zmq library's default (1000). This is a high number and can be set to 2 for gui purposes. One must also set the client's receive high water mark to similar value. Final effect is sum of them. Also restarts receiver zmq streaming if enabled. Can set to -1 to set default value."
|
|
actions:
|
|
GET:
|
|
function: getRxZmqHwm
|
|
PUT:
|
|
function: setRxZmqHwm
|
|
|
|
extrastoragecells:
|
|
inherit_actions: INTEGER_COMMAND_SET_NOID_GET_ID
|
|
help: "[0-15]\n\t[Jungfrau] Only for chipv1.0. Number of additional storage cells. Default is 0. For advanced users only. \n\tThe #images = #frames x #triggers x (#extrastoragecells + 1)."
|
|
actions:
|
|
GET:
|
|
function: getNumberOfAdditionalStorageCells
|
|
PUT:
|
|
function: setNumberOfAdditionalStorageCells
|
|
|
|
bursts:
|
|
inherit_actions: INTEGER_COMMAND_SET_NOID_GET_ID
|
|
help: "[n_bursts]\n\t[Gotthard2] Number of bursts per aquire. Only in auto timing mode and burst mode. Use timing command to set timing mode and burstmode command to set burst mode."
|
|
actions:
|
|
GET:
|
|
function: getNumberOfBursts
|
|
PUT:
|
|
function: setNumberOfBursts
|
|
input_types: [ int64_t ]
|
|
|
|
################# INTEGER_COMMAND_NOID #######################
|
|
fmaster:
|
|
inherit_actions: INTEGER_COMMAND_NOID
|
|
help: "[0, 1]\n\tEnable or disable receiver master file. Default is 1."
|
|
actions:
|
|
GET:
|
|
function: getMasterFileWrite
|
|
PUT:
|
|
function: setMasterFileWrite
|
|
input_types: [ bool ]
|
|
|
|
################# INTEGER_IND_COMMAND #######################
|
|
v_limit:
|
|
inherit_actions: INTEGER_IND_COMMAND
|
|
help: "[n_value]\n\t[Ctb][Xilinx Ctb] Soft limit for power supplies (ctb only) and DACS in mV."
|
|
actions:
|
|
GET:
|
|
function: getPower
|
|
input: [ 'defs::V_LIMIT' ]
|
|
PUT:
|
|
function: setPower
|
|
input: [ 'defs::V_LIMIT', 'args[0]' ]
|
|
|
|
v_a:
|
|
inherit_actions: INTEGER_IND_COMMAND
|
|
help: "[n_value]\n\t[Ctb][Xilinx Ctb] Power supply a in mV."
|
|
actions:
|
|
GET:
|
|
function: getPower
|
|
input: [ 'defs::V_POWER_A' ]
|
|
PUT:
|
|
function: setPower
|
|
input: [ 'defs::V_POWER_A', 'args[0]' ]
|
|
|
|
v_b:
|
|
inherit_actions: INTEGER_IND_COMMAND
|
|
help: "[n_value]\n\t[Ctb][Xilinx Ctb] Power supply b in mV."
|
|
actions:
|
|
GET:
|
|
function: getPower
|
|
input: [ 'defs::V_POWER_B' ]
|
|
PUT:
|
|
function: setPower
|
|
input: [ 'defs::V_POWER_B', 'args[0]' ]
|
|
|
|
v_c:
|
|
inherit_actions: INTEGER_IND_COMMAND
|
|
help: "[n_value]\n\t[Ctb][Xilinx Ctb] Power supply c in mV."
|
|
actions:
|
|
GET:
|
|
function: getPower
|
|
input: [ 'defs::V_POWER_C' ]
|
|
PUT:
|
|
function: setPower
|
|
input: [ 'defs::V_POWER_C', 'args[0]' ]
|
|
|
|
v_d:
|
|
inherit_actions: INTEGER_IND_COMMAND
|
|
help: "[n_value]\n\t[Ctb][Xilinx Ctb] Power supply d in mV."
|
|
actions:
|
|
GET:
|
|
function: getPower
|
|
input: [ 'defs::V_POWER_D' ]
|
|
PUT:
|
|
function: setPower
|
|
input: [ 'defs::V_POWER_D', 'args[0]' ]
|
|
|
|
v_io:
|
|
inherit_actions: INTEGER_IND_COMMAND
|
|
help: "[n_value]\n\t[Ctb][Xilinx Ctb] Power supply io in mV. Minimum 1200 mV. Must be the first power regulator to be set after fpga reset (on-board detector server start up)."
|
|
actions:
|
|
GET:
|
|
function: getPower
|
|
input: [ 'defs::V_POWER_IO' ]
|
|
PUT:
|
|
function: setPower
|
|
input: [ 'defs::V_POWER_IO', 'args[0]' ]
|
|
|
|
v_chip:
|
|
inherit_actions: INTEGER_IND_COMMAND
|
|
help: "[n_value]\n\t[Ctb] Power supply chip in mV. Do not use it unless you are completely sure you will not fry the board."
|
|
actions:
|
|
GET:
|
|
function: getPower
|
|
input: [ 'defs::V_POWER_CHIP' ]
|
|
PUT:
|
|
function: setPower
|
|
input: [ 'defs::V_POWER_CHIP', 'args[0]' ]
|
|
|
|
################# INTEGER_USER_IND_COMMAND ###################
|
|
vchip_comp_fe:
|
|
inherit_actions: INTEGER_USER_IND_COMMAND
|
|
help: "[chip index 0-9, -1 for all][10 bit hex value] \n\t[Gotthard2] On chip Dac for comparator current of analogue front end."
|
|
actions:
|
|
GET:
|
|
function: getOnChipDAC
|
|
input: [ 'defs::VB_COMP_FE', 'args[0]' ]
|
|
PUT:
|
|
function: setOnChipDAC
|
|
input: [ 'defs::VB_COMP_FE', 'args[0]', 'args[1]' ]
|
|
|
|
vchip_opa_1st:
|
|
inherit_actions: INTEGER_USER_IND_COMMAND
|
|
help: "[chip index 0-9, -1 for all][10 bit hex value] \n\t[Gotthard2] On chip Dac for opa current for driving the other DACs in chip."
|
|
actions:
|
|
GET:
|
|
function: getOnChipDAC
|
|
input: [ 'defs::VB_OPA_1ST', 'args[0]' ]
|
|
PUT:
|
|
function: setOnChipDAC
|
|
input: [ 'defs::VB_OPA_1ST', 'args[0]', 'args[1]' ]
|
|
|
|
vchip_opa_fd:
|
|
inherit_actions: INTEGER_USER_IND_COMMAND
|
|
help: "[chip index 0-9, -1 for all][10 bit hex value] \n\t[Gotthard2] On chip Dac current for CDS opa stage."
|
|
actions:
|
|
GET:
|
|
function: getOnChipDAC
|
|
input: [ 'defs::VB_OPA_FD', 'args[0]' ]
|
|
PUT:
|
|
function: setOnChipDAC
|
|
input: [ 'defs::VB_OPA_FD', 'args[0]', 'args[1]' ]
|
|
|
|
vchip_comp_adc:
|
|
inherit_actions: INTEGER_USER_IND_COMMAND
|
|
help: "[chip index 0-9, -1 for all][10 bit hex value] \n\t[Gotthard2] On chip Dac for comparator current of ADC."
|
|
actions:
|
|
GET:
|
|
function: getOnChipDAC
|
|
input: [ 'defs::VB_COMP_ADC', 'args[0]' ]
|
|
PUT:
|
|
function: setOnChipDAC
|
|
input: [ 'defs::VB_COMP_ADC', 'args[0]', 'args[1]' ]
|
|
|
|
vchip_ref_comp_fe:
|
|
inherit_actions: INTEGER_USER_IND_COMMAND
|
|
help: "[chip index 0-9, -1 for all][10 bit hex value] \n\t[Gotthard2] On chip Dac for reference voltage of the comparator of analogue front end."
|
|
actions:
|
|
GET:
|
|
function: getOnChipDAC
|
|
input: [ 'defs::VREF_COMP_FE', 'args[0]' ]
|
|
PUT:
|
|
function: setOnChipDAC
|
|
input: [ 'defs::VREF_COMP_FE', 'args[0]', 'args[1]' ]
|
|
|
|
vchip_cs:
|
|
inherit_actions: INTEGER_USER_IND_COMMAND
|
|
help: "[chip index 0-9, -1 for all][10 bit hex value] \n\t[Gotthard2] On chip Dac for current injection into preamplifier."
|
|
actions:
|
|
GET:
|
|
function: getOnChipDAC
|
|
input: [ 'defs::VB_CS', 'args[0]' ]
|
|
PUT:
|
|
function: setOnChipDAC
|
|
input: [ 'defs::VB_CS', 'args[0]', 'args[1]' ]
|
|
|
|
################# EXECUTE_SET_COMMAND_NOID #######################
|
|
clearbusy:
|
|
inherit_actions: EXECUTE_SET_COMMAND_NOID
|
|
help: "\n\tIf acquisition aborted during acquire command, use this to clear acquiring flag in shared memory before starting next acquisition"
|
|
actions:
|
|
PUT:
|
|
function: clearAcquiringFlag
|
|
|
|
rx_start:
|
|
inherit_actions: EXECUTE_SET_COMMAND_NOID
|
|
help: "\n\tStarts receiver listener for detector data packets and create a data file (if file write enabled)."
|
|
actions:
|
|
PUT:
|
|
function: startReceiver
|
|
|
|
rx_stop:
|
|
inherit_actions: EXECUTE_SET_COMMAND_NOID
|
|
help: "\n\tStops receiver listener for detector data packets and closes current data file (if file write enabled)."
|
|
actions:
|
|
PUT:
|
|
function: stopReceiver
|
|
|
|
readout:
|
|
inherit_actions: EXECUTE_SET_COMMAND_NOID
|
|
help: "\n\t[Mythen3] Starts detector readout. Status changes to TRANSMITTING and automatically returns to idle at the end of readout."
|
|
actions:
|
|
PUT:
|
|
function: startDetectorReadout
|
|
|
|
rx_clearroi:
|
|
inherit_actions: EXECUTE_SET_COMMAND_NOID
|
|
help: "\n\tResets Region of interest in receiver. Default is all channels/pixels enabled."
|
|
actions:
|
|
PUT:
|
|
function: clearRxROI
|
|
|
|
################# EXECUTE_SET_COMMAND ########################
|
|
start:
|
|
inherit_actions: EXECUTE_SET_COMMAND
|
|
help: "\n\tStarts detector acquisition. Status changes to RUNNING or WAITING and automatically returns to idle at the end of acquisition. If the acquisition was abruptly stopped, some detectors come back to STOPPED."
|
|
actions:
|
|
PUT:
|
|
function: startDetector
|
|
|
|
stop:
|
|
inherit_actions: EXECUTE_SET_COMMAND
|
|
help: "\n\tAbort detector acquisition. Status changes to IDLE or STOPPED. Goes to stop server."
|
|
actions:
|
|
PUT:
|
|
function: stopDetector
|
|
|
|
udp_cleardst:
|
|
inherit_actions: EXECUTE_SET_COMMAND
|
|
help: "\n\tClears udp destination details on the detector."
|
|
actions:
|
|
PUT:
|
|
function: clearUDPDestinations
|
|
|
|
udp_reconfigure:
|
|
inherit_actions: EXECUTE_SET_COMMAND
|
|
help: "\n\tReconfigures Detector with UDP destination. More for debugging as the configuration is done automatically when the detector has sufficient UDP details."
|
|
actions:
|
|
PUT:
|
|
function: reconfigureUDPDestination
|
|
|
|
udp_validate:
|
|
inherit_actions: EXECUTE_SET_COMMAND
|
|
help: "\n\tValidates that UDP configuration in the detector is valid. If not configured, it will throw with error message requesting missing udp information."
|
|
actions:
|
|
PUT:
|
|
function: validateUDPConfiguration
|
|
|
|
clearroi:
|
|
inherit_actions: EXECUTE_SET_COMMAND
|
|
help: "\n\t[Gotthard] Resets Region of interest in detector. All channels enabled. Default is all channels enabled."
|
|
actions:
|
|
PUT:
|
|
function: clearROI
|
|
|
|
defaultpattern:
|
|
inherit_actions: EXECUTE_SET_COMMAND
|
|
help: "\n\t[Mythen3] Loads and runs default pattern in pattern generator. It is to go back to initial settings."
|
|
actions:
|
|
PUT:
|
|
function: loadDefaultPattern
|
|
|
|
patternstart:
|
|
inherit_actions: EXECUTE_SET_COMMAND
|
|
help: "\n\t[Mythen3] Starts Pattern"
|
|
actions:
|
|
PUT:
|
|
function: startPattern
|
|
|
|
resetfpga:
|
|
inherit_actions: EXECUTE_SET_COMMAND
|
|
help: "\n\t[Jungfrau][Moench][Ctb][Xilinx Ctb] Reset FPGA."
|
|
actions:
|
|
PUT:
|
|
function: resetFPGA
|
|
|
|
rebootcontroller:
|
|
inherit_actions: EXECUTE_SET_COMMAND
|
|
help: "\n\t[Jungfrau][Moench][Ctb][Gotthard][Mythen3][Gotthard2][Xilinx Ctb] Reboot controller of detector."
|
|
actions:
|
|
PUT:
|
|
function: rebootController
|
|
|
|
firmwaretest:
|
|
inherit_actions: EXECUTE_SET_COMMAND
|
|
help: "\n\t[Jungfrau][Moench][Gotthard][Mythen3][Gotthard2][Ctb][Xilinx Ctb] Firmware test, ie. reads a read fixed pattern from a register."
|
|
actions:
|
|
PUT:
|
|
function: executeFirmwareTest
|
|
|
|
bustest:
|
|
inherit_actions: EXECUTE_SET_COMMAND
|
|
help: "\n\t[Jungfrau][Moench][Gotthard][Mythen3][Gotthard2][Ctb] Bus test, ie. Writes different values in a R/W register and confirms the writes to check bus.\n\tAdvanced User function!"
|
|
actions:
|
|
PUT:
|
|
function: executeBusTest
|
|
|
|
configtransceiver:
|
|
inherit_actions: EXECUTE_SET_COMMAND
|
|
help: "\n\t[Xilinx Ctb] Waits for transceiver to be aligned. Chip had to be configured (powered on) before this."
|
|
actions:
|
|
PUT:
|
|
function: configureTransceiver
|
|
|
|
################# EXECUTE_SET_COMMAND_NOID_1ARG ##############
|
|
config:
|
|
inherit_actions: EXECUTE_SET_COMMAND_NOID_1ARG
|
|
help: "\n\tFrees shared memory before loading configuration file. Set up once."
|
|
actions:
|
|
PUT:
|
|
function: loadConfig
|
|
|
|
parameters:
|
|
inherit_actions: EXECUTE_SET_COMMAND_NOID_1ARG
|
|
help: "\n\tSets detector measurement parameters to those contained in fname. Set up per measurement."
|
|
actions:
|
|
PUT:
|
|
function: loadParameters
|
|
|
|
savepattern:
|
|
inherit_actions: EXECUTE_SET_COMMAND_NOID_1ARG
|
|
help: "\n\t[Ctb][Mythen3][Xilinx Ctb] Saves pattern to file (ascii). \n\t[Ctb] Also executes pattern."
|
|
actions:
|
|
PUT:
|
|
function: savePattern
|
|
|
|
################# GET_COMMAND ################################
|
|
detectorserverversion:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\tOn-board detector server software version"
|
|
actions:
|
|
GET:
|
|
function: getDetectorServerVersion
|
|
|
|
hardwareversion:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\tHardware version of detector. \n\t[Eiger] Hardware version of front FPGA on detector."
|
|
actions:
|
|
GET:
|
|
function: getHardwareVersion
|
|
|
|
kernelversion:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\tGet kernel version on the detector including time and date."
|
|
actions:
|
|
GET:
|
|
function: getKernelVersion
|
|
|
|
rx_version:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\tReceiver version"
|
|
actions:
|
|
GET:
|
|
function: getReceiverVersion
|
|
|
|
moduleid:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\t[Gotthard2][Eiger][Mythen3][Jungfrau][Moench] 16 bit value (ideally unique) that is streamed out in the UDP header of the detector. Picked up from a file on the module."
|
|
actions:
|
|
GET:
|
|
function: getModuleId
|
|
|
|
type:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\tReturns detector type. Can be Eiger, Jungfrau, Gotthard, Moench, Mythen3, Gotthard2, ChipTestBoard, Xilinx_ChipTestBoard"
|
|
actions:
|
|
GET:
|
|
function: getDetectorType
|
|
|
|
framesl:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\t[Gotthard][Jungfrau][Moench][Mythen3][Gotthard2][Ctb][Xilinx Ctb] Number of frames left in acquisition. \n\t[Gotthard2] only in continuous auto mode."
|
|
actions:
|
|
GET:
|
|
function: getNumberOfFramesLeft
|
|
|
|
triggersl:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\t[Gotthard][Jungfrau][Moench][Mythen3][Gotthard2][Ctb][Xilinx Ctb] Number of triggers left in acquisition. Only when external trigger used."
|
|
actions:
|
|
GET:
|
|
function: getNumberOfTriggersLeft
|
|
|
|
maxadcphaseshift:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\t[Jungfrau][Moench][Ctb] Absolute maximum Phase shift of ADC clock."
|
|
actions:
|
|
GET:
|
|
function: getMaxADCPhaseShift
|
|
|
|
maxdbitphaseshift:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\t[Ctb][Jungfrau] Absolute maximum Phase shift of of the clock to latch digital bits."
|
|
actions:
|
|
GET:
|
|
function: getMaxDBITPhaseShift
|
|
|
|
rx_framescaught:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\tNumber of frames caught by each port in receiver."
|
|
actions:
|
|
GET:
|
|
function: getFramesCaught
|
|
|
|
rx_missingpackets:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\tNumber of missing packets for receiver. If negative, they are packets in excess."
|
|
actions:
|
|
GET:
|
|
function: getNumMissingPackets
|
|
|
|
rx_frameindex:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\tCurrent frame index received for each port in receiver during acquisition."
|
|
actions:
|
|
GET:
|
|
function: getRxCurrentFrameIndex
|
|
|
|
scanerrmsg:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\tGets Scan error message if scan ended in error for non blocking acquisitions."
|
|
actions:
|
|
GET:
|
|
function: getScanErrorMessage
|
|
|
|
udp_numdst:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\t[Jungfrau][Moench][Eiger][Mythen3][Gotthard2] One can enter upto 32 (64 for Mythen3) destinations that the detector will stream images out in a round robin fashion. This is get only command. Default: 1"
|
|
actions:
|
|
GET:
|
|
function: getNumberofUDPDestinations
|
|
|
|
rx_printconfig:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\tPrints the receiver configuration."
|
|
actions:
|
|
GET:
|
|
function: printRxConfiguration
|
|
|
|
rx_realudpsocksize:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\tActual udp socket buffer size. Double the size of rx_udpsocksize due to kernel bookkeeping."
|
|
actions:
|
|
GET:
|
|
function: getRxRealUDPSocketBufferSize
|
|
|
|
rx_lastclient:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\tClient IP Address that last communicated with the receiver."
|
|
actions:
|
|
GET:
|
|
function: getRxLastClientIP
|
|
|
|
rx_threads:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\tGet kernel thread ids from the receiver in order of [parent, tcp, listener 0, processor 0, streamer 0, listener 1, processor 1, streamer 1, arping]. If no streamer yet or there is no second interface, it gives 0 in its place."
|
|
actions:
|
|
GET:
|
|
function: getRxThreadIds
|
|
|
|
chipversion:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\t[Jungfrau] Returns chip version. Can be 1.0 or 1.1"
|
|
actions:
|
|
GET:
|
|
function: getChipVersion
|
|
|
|
burstsl:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\t[Gotthard2] Number of bursts left in acquisition. Only in burst auto mode."
|
|
actions:
|
|
GET:
|
|
function: getNumberOfBurstsLeft
|
|
|
|
syncclk:
|
|
inherit_actions: GET_COMMAND
|
|
help: "[n_clk in MHz]\n\t[Ctb] Sync clock in MHz."
|
|
actions:
|
|
GET:
|
|
function: getSYNCClock
|
|
|
|
patfname:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\t[Ctb][Mythen3][Xilinx Ctb] Gets the pattern file name including path of the last pattern uploaded. Returns an empty if nothing was uploaded or via a server default file"
|
|
actions:
|
|
GET:
|
|
function: getPatterFileName
|
|
|
|
lastclient:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\tClient IP Address that last communicated with the detector."
|
|
actions:
|
|
GET:
|
|
function: getLastClientIP
|
|
|
|
framecounter:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\t[Jungfrau][Moench][Mythen3][Gotthard2][Ctb][Xilinx Ctb] Number of frames from start run control.\n\t[Gotthard2] only in continuous mode."
|
|
actions:
|
|
GET:
|
|
function: getNumberOfFramesFromStart
|
|
|
|
################# GET_COMMAND_HEX ############################
|
|
serialnumber:
|
|
inherit_actions: GET_COMMAND
|
|
help: "\n\t[Jungfrau][Moench][Gotthard][Mythen3][Gotthard2][Ctb]\n\tSerial number of detector."
|
|
actions:
|
|
GET:
|
|
function: getSerialNumber
|
|
output: [ "OutStringHex(t)" ]
|
|
|
|
################# GET_COMMAND_NOID ###########################
|
|
nmod:
|
|
inherit_actions: GET_COMMAND_NOID
|
|
help: "\n\tNumber of modules in shared memory."
|
|
actions:
|
|
GET:
|
|
function: size
|
|
|
|
settingslist:
|
|
inherit_actions: GET_COMMAND_NOID
|
|
help: "\n\tList of settings implemented for this detector."
|
|
actions:
|
|
GET:
|
|
function: getSettingsList
|
|
|
|
drlist:
|
|
inherit_actions: GET_COMMAND_NOID
|
|
help: "\n\tGets the list of dynamic ranges for this detector."
|
|
actions:
|
|
GET:
|
|
function: getDynamicRangeList
|
|
|
|
timinglist:
|
|
inherit_actions: GET_COMMAND_NOID
|
|
help: "\n\tGets the list of timing modes for this detector."
|
|
actions:
|
|
GET:
|
|
function: getTimingModeList
|
|
|
|
readoutspeedlist:
|
|
inherit_actions: GET_COMMAND_NOID
|
|
help: "\n\tList of readout speed levels implemented for this detector."
|
|
actions:
|
|
GET:
|
|
function: getReadoutSpeedList
|
|
|
|
templist:
|
|
inherit_actions: GET_COMMAND_NOID
|
|
help: "\n\tList of temperature commands implemented for this detector."
|
|
actions:
|
|
GET:
|
|
function: getTemperatureList
|
|
|
|
################# GET_IND_COMMAND ############################
|
|
temp_adc:
|
|
inherit_actions: GET_IND_COMMAND
|
|
help: "[n_value]\n\t[Jungfrau][Moench][Gotthard] ADC Temperature"
|
|
actions:
|
|
GET:
|
|
function: getTemperature
|
|
input: [ 'defs::TEMPERATURE_ADC' ]
|
|
output: [ OutString(t), '" °C"' ]
|
|
|
|
temp_fpga:
|
|
inherit_actions: GET_IND_COMMAND
|
|
help: "[n_value]\n\t[Eiger][Jungfrau][Moench][Gotthard][Mythen3][Gotthard2][Xilinx CTB] FPGA Temperature"
|
|
actions:
|
|
GET:
|
|
function: getTemperature
|
|
input: [ 'defs::TEMPERATURE_FPGA' ]
|
|
output: [ OutString(t), '" °C"' ]
|
|
|
|
temp_fpgaext:
|
|
inherit_actions: GET_IND_COMMAND
|
|
help: "[n_value]\n\t[Eiger]Temperature close to the FPGA"
|
|
actions:
|
|
GET:
|
|
function: getTemperature
|
|
input: [ 'defs::TEMPERATURE_FPGAEXT' ]
|
|
output: [ OutString(t), '" °C"' ]
|
|
|
|
temp_10ge:
|
|
inherit_actions: GET_IND_COMMAND
|
|
help: "[n_value]\n\t[Eiger]Temperature close to the 10GbE"
|
|
actions:
|
|
GET:
|
|
function: getTemperature
|
|
input: [ 'defs::TEMPERATURE_10GE' ]
|
|
output: [ OutString(t), '" °C"' ]
|
|
|
|
temp_dcdc:
|
|
inherit_actions: GET_IND_COMMAND
|
|
help: "[n_value]\n\t[Eiger]Temperature close to the dc dc converter"
|
|
actions:
|
|
GET:
|
|
function: getTemperature
|
|
input: [ 'defs::TEMPERATURE_DCDC' ]
|
|
output: [ OutString(t), '" °C"' ]
|
|
|
|
temp_sodl:
|
|
inherit_actions: GET_IND_COMMAND
|
|
help: "[n_value]\n\t[Eiger]Temperature close to the left so-dimm memory"
|
|
actions:
|
|
GET:
|
|
function: getTemperature
|
|
input: [ 'defs::TEMPERATURE_SODL' ]
|
|
output: [ OutString(t), '" °C"' ]
|
|
|
|
temp_sodr:
|
|
inherit_actions: GET_IND_COMMAND
|
|
help: "[n_value]\n\t[Eiger]Temperature close to the right so-dimm memory"
|
|
actions:
|
|
GET:
|
|
function: getTemperature
|
|
input: [ 'defs::TEMPERATURE_SODR' ]
|
|
output: [ OutString(t), '" °C"' ]
|
|
|
|
temp_fpgafl:
|
|
inherit_actions: GET_IND_COMMAND
|
|
help: "[n_value]\n\t[Eiger]Temperature of the left front end board fpga."
|
|
actions:
|
|
GET:
|
|
function: getTemperature
|
|
input: [ 'defs::TEMPERATURE_FPGA2' ]
|
|
output: [ OutString(t), '" °C"' ]
|
|
|
|
temp_fpgafr:
|
|
inherit_actions: GET_IND_COMMAND
|
|
help: "[n_value]\n\t[Eiger]Temperature of the right front end board fpga."
|
|
actions:
|
|
GET:
|
|
function: getTemperature
|
|
input: [ 'defs::TEMPERATURE_FPGA3' ]
|
|
output: [ OutString(t), '" °C"' ]
|
|
|
|
temp_slowadc:
|
|
inherit_actions: GET_IND_COMMAND
|
|
help: "[n_value]\n\t[Ctb]Temperature of the slow adc"
|
|
actions:
|
|
GET:
|
|
function: getTemperature
|
|
input: [ 'defs::SLOW_ADC_TEMP' ]
|
|
output: [ OutString(t), '" °C"' ]
|
|
|
|
vm_a:
|
|
inherit_actions: GET_IND_COMMAND
|
|
help: "\n\t[Ctb] Measured voltage of power supply a in mV."
|
|
actions:
|
|
GET:
|
|
function: getMeasuredPower
|
|
input: [ 'defs::V_POWER_A' ]
|
|
|
|
vm_b:
|
|
inherit_actions: GET_IND_COMMAND
|
|
help: "\n\t[Ctb] Measured voltage of power supply b in mV."
|
|
actions:
|
|
GET:
|
|
function: getMeasuredPower
|
|
input: [ 'defs::V_POWER_B' ]
|
|
|
|
vm_c:
|
|
inherit_actions: GET_IND_COMMAND
|
|
help: "\n\t[Ctb] Measured voltage of power supply c in mV."
|
|
actions:
|
|
GET:
|
|
function: getMeasuredPower
|
|
input: [ 'defs::V_POWER_C' ]
|
|
|
|
vm_d:
|
|
inherit_actions: GET_IND_COMMAND
|
|
help: "\n\t[Ctb] Measured voltage of power supply d in mV."
|
|
actions:
|
|
GET:
|
|
function: getMeasuredPower
|
|
input: [ 'defs::V_POWER_D' ]
|
|
|
|
vm_io:
|
|
inherit_actions: GET_IND_COMMAND
|
|
help: "\n\t[Ctb] Measured voltage of power supply io in mV."
|
|
actions:
|
|
GET:
|
|
function: getMeasuredPower
|
|
input: [ 'defs::V_POWER_IO' ]
|
|
|
|
im_a:
|
|
inherit_actions: GET_IND_COMMAND
|
|
help: "\n\t[Ctb] Measured current of power supply a in mA."
|
|
actions:
|
|
GET:
|
|
function: getMeasuredCurrent
|
|
input: [ 'defs::I_POWER_A' ]
|
|
|
|
im_b:
|
|
inherit_actions: GET_IND_COMMAND
|
|
help: "\n\t[Ctb] Measured current of power supply b in mA."
|
|
actions:
|
|
GET:
|
|
function: getMeasuredCurrent
|
|
input: [ 'defs::I_POWER_B' ]
|
|
|
|
im_c:
|
|
inherit_actions: GET_IND_COMMAND
|
|
help: "\n\t[Ctb] Measured current of power supply c in mA."
|
|
actions:
|
|
GET:
|
|
function: getMeasuredCurrent
|
|
input: [ 'defs::I_POWER_C' ]
|
|
|
|
im_d:
|
|
inherit_actions: GET_IND_COMMAND
|
|
help: "\n\t[Ctb] Measured current of power supply d in mA."
|
|
actions:
|
|
GET:
|
|
function: getMeasuredCurrent
|
|
input: [ 'defs::I_POWER_D' ]
|
|
|
|
im_io:
|
|
inherit_actions: GET_IND_COMMAND
|
|
help: "\n\t[Ctb] Measured current of power supply io in mA."
|
|
actions:
|
|
GET:
|
|
function: getMeasuredCurrent
|
|
input: [ 'defs::I_POWER_IO' ]
|
|
|
|
################# CTB_NAMED_LIST #############################
|
|
daclist:
|
|
inherit_actions: CTB_NAMED_LIST
|
|
help: "[dacname1 dacname2 .. dacname18] \n\t\t[Ctb][Xilinx_Ctb] Set the list of dac names for this detector.\n\t\t[All] Gets the list of dac names for every dac for this detector."
|
|
actions:
|
|
GET:
|
|
function: getDacNames
|
|
PUT:
|
|
function: setDacNames
|
|
|
|
adclist:
|
|
inherit_actions: CTB_NAMED_LIST
|
|
help: "[adcname1 adcname2 .. adcname32] \n\t\t[Ctb][Xilinx_Ctb] Set the list of adc names for this board."
|
|
actions:
|
|
GET:
|
|
function: getAdcNames
|
|
PUT:
|
|
function: setAdcNames
|
|
|
|
signallist:
|
|
inherit_actions: CTB_NAMED_LIST
|
|
help: "[signalname1 signalname2 .. signalname63] \n\t\t[Ctb][Xilinx_Ctb] Set the list of signal names for this board."
|
|
actions:
|
|
GET:
|
|
function: getSignalNames
|
|
PUT:
|
|
function: setSignalNames
|
|
|
|
powerlist:
|
|
inherit_actions: CTB_NAMED_LIST
|
|
help: "[powername1 powername2 .. powername4] \n\t\t[Ctb][Xilinx_Ctb] Set the list of power names for this board."
|
|
actions:
|
|
GET:
|
|
function: getPowerNames
|
|
PUT:
|
|
function: setPowerNames
|
|
|
|
slowadclist:
|
|
inherit_actions: CTB_NAMED_LIST
|
|
help: "[slowadcname1 slowadcname2 .. slowadcname7] \n\t\t[Ctb][Xilinx_Ctb] Set the list of slowadc names for this board."
|
|
actions:
|
|
GET:
|
|
function: getSlowADCNames
|
|
PUT:
|
|
function: setSlowADCNames
|
|
|
|
################# CTB_VALUES ################################
|
|
powervalues:
|
|
help: "[name] \n\t\t[Ctb][Xilinx_Ctb] Get values of all powers."
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
ctb_output_list:
|
|
GETFCNLIST: getPowerList
|
|
GETFCNNAME: getPowerNames
|
|
GETFCN: getPower
|
|
suffix: "mV"
|
|
printable_name: "*name_it++"
|
|
|
|
slowadcvalues:
|
|
help: "[name] \n\t\t[Ctb][Xilinx_Ctb] Get values of all slow adcs."
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
ctb_output_list:
|
|
GETFCNLIST: getSlowADCList
|
|
GETFCNNAME: getSlowADCNames
|
|
GETFCN: getSlowADC
|
|
suffix: "uV"
|
|
printable_name: "*name_it++"
|
|
|
|
tempvalues:
|
|
help: "\n\tGets the values for every temperature for this detector."
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
ctb_output_list:
|
|
GETFCNLIST: getTemperatureList
|
|
GETFCNNAME: ""
|
|
GETFCN: getTemperature
|
|
suffix: "°C"
|
|
printable_name: "*it"
|
|
|
|
################# CTB_SINGLE_DACNAME ########################
|
|
dacname:
|
|
inherit_actions: CTB_SINGLE_DACNAME
|
|
help: "[0-17][name] \n\t\t[Ctb][Xilinx_Ctb] Set the dac at the given position to the given name."
|
|
actions:
|
|
GET:
|
|
function: getDacName
|
|
extra_variables:
|
|
- name: index
|
|
type: defs::dacIndex
|
|
value: defs::DAC_0
|
|
PUT:
|
|
function: setDacName
|
|
extra_variables:
|
|
- name: index
|
|
type: defs::dacIndex
|
|
value: defs::DAC_0
|
|
|
|
powername:
|
|
inherit_actions: CTB_SINGLE_DACNAME
|
|
help: "[0-4][name] \n\t\t[Ctb][Xilinx_Ctb] Set the power at the given position to the given name."
|
|
actions:
|
|
GET:
|
|
function: getPowerName
|
|
extra_variables:
|
|
- name: index
|
|
type: defs::dacIndex
|
|
value: defs::V_POWER_A
|
|
PUT:
|
|
function: setPowerName
|
|
extra_variables:
|
|
- name: index
|
|
type: defs::dacIndex
|
|
value: defs::V_POWER_A
|
|
|
|
slowadcname:
|
|
inherit_actions: CTB_SINGLE_DACNAME
|
|
help: "[0-7][name] \n\t\t[Ctb][Xilinx_Ctb] Set the slowadc at the given position to the given name."
|
|
actions:
|
|
GET:
|
|
function: getSlowADCName
|
|
extra_variables:
|
|
- name: index
|
|
type: defs::dacIndex
|
|
value: defs::SLOW_ADC0
|
|
PUT:
|
|
function: setSlowADCName
|
|
extra_variables:
|
|
- name: index
|
|
type: defs::dacIndex
|
|
value: defs::SLOW_ADC0
|
|
|
|
################# CTB_GET_DACINDEX ##########################
|
|
dacindex:
|
|
inherit_actions: CTB_GET_DACINDEX
|
|
help: "[name] \n\t\t[Ctb][Xilinx_Ctb] Get the dac index for the given name."
|
|
actions:
|
|
GET:
|
|
function: getDacIndex
|
|
extra_variables:
|
|
- name: index
|
|
type: defs::dacIndex
|
|
value: defs::DAC_0
|
|
|
|
powerindex:
|
|
inherit_actions: CTB_GET_DACINDEX
|
|
help: "[name] \n\t\t[Ctb][Xilinx_Ctb] Get the power index for the given name."
|
|
actions:
|
|
GET:
|
|
function: getPowerIndex
|
|
extra_variables:
|
|
- name: index
|
|
type: defs::dacIndex
|
|
value: defs::V_POWER_A
|
|
|
|
slowadcindex:
|
|
inherit_actions: CTB_GET_DACINDEX
|
|
help: "[name] \n\t\t[Ctb][Xilinx_Ctb] Get the slowadc index for the given name."
|
|
actions:
|
|
GET:
|
|
function: getSlowADCIndex
|
|
extra_variables:
|
|
- name: index
|
|
type: defs::dacIndex
|
|
value: defs::SLOW_ADC0
|
|
|
|
################# CTB_SINGLE_NAME ###########################
|
|
adcname:
|
|
inherit_actions: CTB_SINGLE_NAME
|
|
help: "[0-31][name] \n\t\t[Ctb][Xilinx_Ctb] Set the adc at the given position to the given name."
|
|
actions:
|
|
GET:
|
|
function: getAdcName
|
|
PUT:
|
|
function: setAdcName
|
|
|
|
signalname:
|
|
inherit_actions: CTB_SINGLE_NAME
|
|
help: "[0-63][name] \n\t\t[Ctb][Xilinx_Ctb] Set the signal at the given position to the given name."
|
|
actions:
|
|
GET:
|
|
function: getSignalName
|
|
PUT:
|
|
function: setSignalName
|
|
|
|
################# CTB_GET_INDEX #############################
|
|
adcindex:
|
|
inherit_actions: CTB_GET_INDEX
|
|
help: "[name] \n\t\t[Ctb][Xilinx_Ctb] Get the adc index for the given name."
|
|
actions:
|
|
GET:
|
|
function: getAdcIndex
|
|
|
|
signalindex:
|
|
inherit_actions: CTB_GET_INDEX
|
|
help: "[name] \n\t\t[Ctb][Xilinx_Ctb] Get the signal index for the given name."
|
|
actions:
|
|
GET:
|
|
function: getSignalIndex
|
|
|
|
|
|
######################### description only commands #############################
|
|
## code is generated for these commands
|
|
free:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
PUT:
|
|
argc: 0
|
|
|
|
hostname:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
PUT:
|
|
argc: -1
|
|
arg_types: [ std::string ]
|
|
|
|
acquire:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
PUT:
|
|
argc: 0
|
|
|
|
versions:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
|
|
threshold:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
PUT:
|
|
args:
|
|
- argc: 1
|
|
arg_types: [ int ]
|
|
- argc: 2
|
|
arg_types: [ int, defs::detectorSettings ]
|
|
- argc: 3
|
|
arg_types: [ int,int,int ]
|
|
- argc: 4
|
|
arg_types: [ int ,int,int,defs::detectorSettings]
|
|
|
|
thresholdnotb:
|
|
is_description: true
|
|
duplicate_function: true
|
|
function_alias: threshold
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
PUT:
|
|
args:
|
|
- argc: 1
|
|
arg_types: [ int ]
|
|
- argc: 2
|
|
arg_types: [ int, defs::detectorSettings ]
|
|
- argc: 3
|
|
arg_types: [ int,int,int ]
|
|
- argc: 4
|
|
arg_types: [ int ,int,int,defs::detectorSettings ]
|
|
|
|
trimen:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
PUT:
|
|
argc: -1
|
|
|
|
badchannels:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 1
|
|
arg_types: [ std::string ]
|
|
PUT:
|
|
argc: -1
|
|
|
|
udp_srcip:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
PUT:
|
|
argc: 1
|
|
arg_types: [ std::string ]
|
|
|
|
udp_srcip2:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
PUT:
|
|
argc: 1
|
|
arg_types: [ std::string ]
|
|
|
|
udp_dstip:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
PUT:
|
|
argc: 1
|
|
arg_types: [ std::string ]
|
|
|
|
udp_dstip2:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
PUT:
|
|
argc: 1
|
|
arg_types: [ std::string ]
|
|
|
|
rx_hostname:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
PUT:
|
|
argc: -1
|
|
|
|
rx_zmqip:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
PUT:
|
|
argc: -1
|
|
|
|
rx_roi:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
PUT:
|
|
args:
|
|
- argc: 2
|
|
arg_types: [ int, int ]
|
|
- argc: 4
|
|
arg_types: [ int, int, int, int ]
|
|
|
|
ratecorr:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
PUT:
|
|
argc: 1
|
|
arg_types: [ int ]
|
|
|
|
burstmode:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
PUT:
|
|
argc: 1
|
|
arg_types: [ defs::burstMode ]
|
|
|
|
vetostream:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
PUT:
|
|
argc: -1
|
|
|
|
counters:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
PUT:
|
|
argc: -1
|
|
|
|
samples:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
PUT:
|
|
argc: 1
|
|
arg_types: [ int ]
|
|
|
|
slowadc:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 1
|
|
arg_types: [ int ]
|
|
|
|
rx_dbitlist:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
PUT:
|
|
argc: -1
|
|
|
|
rx_jsonaddheader:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
PUT:
|
|
argc: -1
|
|
|
|
execcommand:
|
|
is_description: true
|
|
actions:
|
|
PUT:
|
|
argc: -1
|
|
|
|
dacvalues:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
args:
|
|
- argc: 0
|
|
- argc: 1
|
|
arg_types: [ special::mv ]
|
|
|
|
currentsource:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
PUT:
|
|
args:
|
|
- argc: 1
|
|
arg_types: [ bool ]
|
|
- argc: 3
|
|
arg_types: [ bool, special::currentSourceFix, int ]
|
|
- argc: 4
|
|
arg_types: [bool, special::currentSourceFix, int, special::currentSourceLow ]
|
|
|
|
gaincaps:
|
|
is_description: true
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
PUT:
|
|
argc: -1
|
|
arg_types: [ defs::defs::M3_GainCaps ]
|
|
|
|
sleep:
|
|
is_description: true
|
|
actions:
|
|
PUT:
|
|
args:
|
|
- argc: 1
|
|
arg_types: [ int ]
|
|
- argc: 2
|
|
arg_types: [ int, special::time_unit ]
|
|
|
|
|
|
################# special commands ##########################
|
|
|
|
virtual:
|
|
function_alias: virtualFunction
|
|
help: "[n_servers] [starting_port_number]\n\tConnecs to n virtual server at local host starting at specific control port. Every virtual server will have a stop port (control port + 1)"
|
|
actions:
|
|
PUT:
|
|
function: setVirtualDetectorServers
|
|
argc: 2
|
|
check_det_id: true
|
|
input: [ 'args[0]', 'args[1]' ]
|
|
input_types: [ int, uint16_t ]
|
|
cast_input: [ true, true ]
|
|
output: [ 'ToString(args)' ]
|
|
|
|
packageversion:
|
|
help: "\n\tPackage version."
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
function: getPackageVersion
|
|
output: [ t ]
|
|
|
|
clientversion:
|
|
help: "\n\tClient software version"
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
function: getClientVersion
|
|
output: [ t ]
|
|
|
|
firmwareversion:
|
|
help: "\n\tFirmware version of detector in format [0xYYMMDD] or an increasing 2 digit number for Eiger."
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
require_det_id: true
|
|
function: getFirmwareVersion
|
|
output: [ OutStringHex(t) ]
|
|
detectors:
|
|
EIGER:
|
|
output: [ OutString(t) ]
|
|
|
|
detsize:
|
|
help: "[nx] [ny]\n\tDetector size, ie. Number of channels in x and y dim. This is used to calculate module coordinates included in UDP data. \n\tBy default, it adds module in y dimension for 2d detectors and in x dimension for 1d detectors packet header."
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
function: getDetectorSize
|
|
output: [ t ]
|
|
PUT:
|
|
argc: 2
|
|
function: setDetectorSize
|
|
input: [ 'defs::xy(StringTo<int>(args[0]),StringTo<int>(args[1]))' ]
|
|
input_types: [ defs::xy ]
|
|
arg_types: [int, int]
|
|
output: [ 'ToString(args)' ]
|
|
|
|
trimbits:
|
|
infer_action: true
|
|
help: "[fname]\n\t[Eiger][Mythen3] Put will load the trimbit file to detector. If no extension specified, serial number of each module is attached. Get will save the trimbits from the detector to file with serial number added to file name."
|
|
actions:
|
|
GET:
|
|
argc: 1
|
|
require_det_id: true
|
|
store_result_in_t: false
|
|
function: saveTrimbits
|
|
input: [ 'args[0]' ]
|
|
input_types: [ std::string ]
|
|
arg_types: [special::path]
|
|
output: [ "args[0]" ]
|
|
PUT:
|
|
argc: 1
|
|
require_det_id: true
|
|
function: loadTrimbits
|
|
input: [ 'args[0]' ]
|
|
input_types: [ std::string ]
|
|
arg_types: [special::path]
|
|
output: [ "args[0]" ]
|
|
|
|
gappixels:
|
|
help: "[0, 1]\n\t[Eiger][Jungfrau][Moench] Include Gap pixels in client data call back in Detecor api. Will not be in detector streaming, receiver file or streaming. Default is 0. "
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
check_det_id: true
|
|
function: getGapPixelsinCallback
|
|
output: [ t ]
|
|
PUT:
|
|
argc: 1
|
|
check_det_id: true
|
|
function: setGapPixelsinCallback
|
|
input: [ 'args[0]' ]
|
|
input_types: [ bool ]
|
|
cast_input: [ true ]
|
|
output: [ args.front() ]
|
|
|
|
Exptime:
|
|
template: true
|
|
infer_action: true # infer action based on actions' argc (they must be unique if true)
|
|
actions:
|
|
GET:
|
|
require_det_id: true
|
|
function: ''
|
|
args:
|
|
- argc: 0
|
|
output: [ OutString(t) ]
|
|
- argc: 1
|
|
arg_types: [ special::time_unit ]
|
|
output: [ "OutString(t , args[0])" ]
|
|
PUT:
|
|
require_det_id: true
|
|
function: ''
|
|
input: [ converted_time ]
|
|
input_types: [ time::ns ]
|
|
args:
|
|
- argc: 1
|
|
arg_types: [ std::string ]
|
|
separate_time_units:
|
|
input: 'args[0]'
|
|
output: [ converted_time, unit ]
|
|
output: [ 'args[0]' ]
|
|
- argc: 2
|
|
arg_types: [ int, special::time_unit ]
|
|
convert_to_time:
|
|
input: [ 'args[0]', 'args[1]' ]
|
|
output: converted_time
|
|
output: [ 'args[0]', 'args[1]' ]
|
|
|
|
exptime:
|
|
inherit_actions: Exptime
|
|
help: "[duration] [(optional unit) ns|us|ms|s]\n\t[Eiger][Jungfrau][Moench][Gotthard][Gotthard2][Ctb][Xilinx Ctb] Exposure time\n\t[Mythen3] Exposure time of all gate signals in auto and trigger mode (internal gating). To specify gate index, use exptime1, exptime2, exptime3."
|
|
actions:
|
|
GET:
|
|
function: getExptime
|
|
detectors:
|
|
MYTHEN3:
|
|
function: getExptimeForAllGates
|
|
PUT:
|
|
function: setExptime
|
|
|
|
exptime1:
|
|
inherit_actions: Exptime
|
|
help: "[n_value]\n\t[Mythen3] Exposure time of gate signal 1 in auto and trigger mode (internal gating)."
|
|
actions:
|
|
GET:
|
|
extra_variables:
|
|
- name: gateIndex
|
|
type: int
|
|
value: 0
|
|
function: getExptime
|
|
input: [ gateIndex ]
|
|
input_types: [ int ]
|
|
PUT:
|
|
extra_variables:
|
|
- name: gateIndex
|
|
type: int
|
|
value: 0
|
|
function: setExptime
|
|
input: [ gateIndex,converted_time ]
|
|
input_types: [ int, time::ns ]
|
|
|
|
exptime2:
|
|
inherit_actions: exptime1
|
|
help: "[n_value]\n\t[Mythen3] Exposure time of gate signal 2 in auto and trigger mode (internal gating)."
|
|
actions:
|
|
GET:
|
|
extra_variables:
|
|
- name: gateIndex
|
|
type: int
|
|
value: 1
|
|
PUT:
|
|
extra_variables:
|
|
- name: gateIndex
|
|
type: int
|
|
value: 1
|
|
|
|
exptime3:
|
|
inherit_actions: exptime1
|
|
help: "[n_value]\n\t[Mythen3] Exposure time of gate signal 3 in auto and trigger mode (internal gating)."
|
|
actions:
|
|
GET:
|
|
extra_variables:
|
|
- name: gateIndex
|
|
type: int
|
|
value: 2
|
|
PUT:
|
|
extra_variables:
|
|
- name: gateIndex
|
|
type: int
|
|
value: 2
|
|
|
|
readoutspeed:
|
|
help: "\n\t[0 or full_speed|1 or half_speed|2 or quarter_speed]\n\t[Eiger][Jungfrau][Moench][Mythen3] Readout speed of chip.\n\t[Eiger][Moench] Default speed is full_speed.\n\t[Jungfrau][Mythen3] Default speed is half_speed. \n\t[Jungfrau] full_speed option only available from v2.0 boards and is recommended to set number of interfaces to 2. Also overwrites adcphase to recommended default.\n\t [144|108]\n\t\t[Gotthard2] Readout speed of chip in MHz. Default is 108."
|
|
actions:
|
|
GET:
|
|
extra_variables:
|
|
- name: det_type
|
|
type: auto
|
|
value: det->getDetectorType().squash(defs::GENERIC);
|
|
exceptions:
|
|
- condition: 'det_type == defs::CHIPTESTBOARD || det_type == defs::XILINX_CHIPTESTBOARD'
|
|
message: '"ReadoutSpeed not implemented. Did you mean runclk?"'
|
|
argc: 0
|
|
require_det_id: true
|
|
function: getReadoutSpeed
|
|
output: [ OutString(t) ]
|
|
PUT:
|
|
extra_variables:
|
|
- name: det_type
|
|
type: auto
|
|
value: det->getDetectorType().squash(defs::GENERIC);
|
|
exceptions:
|
|
- condition: 'det_type == defs::CHIPTESTBOARD || det_type == defs::XILINX_CHIPTESTBOARD'
|
|
message: '"ReadoutSpeed not implemented. Did you mean runclk?"'
|
|
argc: 1
|
|
require_det_id: true
|
|
function: setReadoutSpeed
|
|
input: [ 'args[0]' ]
|
|
input_types: [ defs::speedLevel ]
|
|
cast_input: [ true ]
|
|
output: [ 'ToString(StringTo<defs::speedLevel>(args[0]))' ]
|
|
|
|
adcphase:
|
|
infer_action: true
|
|
help: "[n_value] [(optional)deg]\n\t[Jungfrau][Moench][Ctb][Gotthard] Phase shift of ADC clock. \n\t[Jungfrau][Moench] Absolute phase shift. If deg used, then shift in degrees. Changing Speed also resets adcphase to recommended defaults.\n\t[Ctb] Absolute phase shift. If deg used, then shift in degrees. Changing adcclk also resets adcphase and sets it to previous values.\n\t[Gotthard] Relative phase shift. Cannot get"
|
|
actions:
|
|
GET:
|
|
require_det_id: true
|
|
extra_variables:
|
|
- name: det_type
|
|
type: auto
|
|
value: det->getDetectorType().squash(defs::GENERIC);
|
|
|
|
exceptions:
|
|
- condition: 'det_type == defs::EIGER || det_type == defs::MYTHEN3 || det_type == defs::GOTTHARD2'
|
|
message: '"adcphase not implemented for this detector"'
|
|
args:
|
|
- argc: 0
|
|
function: getADCPhase
|
|
output: [ OutString(t) ]
|
|
- argc: 1
|
|
exceptions:
|
|
- condition: 'det_type == defs::EIGER || det_type == defs::MYTHEN3 || det_type == defs::GOTTHARD2'
|
|
message: '"adcphase not implemented for this detector"'
|
|
- condition: 'args[0] != "deg"'
|
|
message: '"Unknown adcphase argument " + args[0] + ". Did you mean deg? "'
|
|
function: getADCPhaseInDegrees
|
|
arg_types: [ special::deg ]
|
|
output: [ OutString(t), '" deg"' ]
|
|
|
|
PUT:
|
|
extra_variables:
|
|
- name: det_type
|
|
type: auto
|
|
value: det->getDetectorType().squash(defs::GENERIC);
|
|
exceptions:
|
|
- condition: 'det_type == defs::EIGER || det_type == defs::MYTHEN3 || det_type == defs::GOTTHARD2'
|
|
message: '"adcphase not implemented for this detector"'
|
|
require_det_id: true
|
|
input: [ 'args[0]' ]
|
|
input_types: [ int ]
|
|
cast_input: [ true ]
|
|
|
|
args:
|
|
- argc: 1
|
|
function: setADCPhase
|
|
output: [ 'args.front()' ]
|
|
- argc: 2
|
|
arg_types: [ int, special::deg ]
|
|
exceptions:
|
|
- condition: 'det_type == defs::EIGER || det_type == defs::MYTHEN3 || det_type == defs::GOTTHARD2'
|
|
message: '"adcphase not implemented for this detector"'
|
|
- condition: 'args[1] != "deg"'
|
|
message: '"Unknown adcphase 2nd argument " + args[1] + ". Did you mean deg?"'
|
|
|
|
function: setADCPhaseInDegrees
|
|
output: [ 'args[0]',"' '", 'args[1]' ]
|
|
|
|
dbitphase:
|
|
help: "[n_value] [(optional)deg]\n\t[Ctb][Jungfrau] Phase shift of clock to latch digital bits. Absolute phase shift. If deg used, then shift in degrees. \n\t[Ctb]Changing dbitclk also resets dbitphase and sets to previous values."
|
|
actions:
|
|
GET:
|
|
extra_variables:
|
|
- name: det_type
|
|
type: auto
|
|
value: det->getDetectorType().squash(defs::GENERIC);
|
|
|
|
exceptions:
|
|
- condition: 'det_type == defs::EIGER || det_type == defs::MYTHEN3 || det_type == defs::GOTTHARD2 || det_type == defs::MOENCH'
|
|
message: '"dbitphase not implemented for this detector"'
|
|
require_det_id: true
|
|
args:
|
|
- argc: 0
|
|
function: getDBITPhase
|
|
output: [ OutString(t) ]
|
|
- argc: 1
|
|
exceptions:
|
|
- condition: 'det_type == defs::EIGER || det_type == defs::MYTHEN3 || det_type == defs::GOTTHARD2 || det_type == defs::MOENCH'
|
|
message: '"dbitphase not implemented for this detector"'
|
|
- condition: 'args[0] != "deg"'
|
|
message: '"Unknown dbitphase argument " + args[0] + ". Did you mean deg? "'
|
|
function: getDBITPhaseInDegrees
|
|
arg_types: [ special::deg ]
|
|
output: [ OutString(t), '" deg"' ]
|
|
PUT:
|
|
extra_variables:
|
|
- name: det_type
|
|
type: auto
|
|
value: det->getDetectorType().squash(defs::GENERIC);
|
|
|
|
exceptions:
|
|
- condition: 'det_type == defs::EIGER || det_type == defs::MYTHEN3 || det_type == defs::GOTTHARD2 || det_type == defs::MOENCH'
|
|
message: '"dbitphase not implemented for this detector"'
|
|
require_det_id: true
|
|
input: [ 'args[0]' ]
|
|
input_types: [ int ]
|
|
cast_input: [ true ]
|
|
args:
|
|
- argc: 1
|
|
function: setDBITPhase
|
|
output: [ 'args.front()' ]
|
|
- argc: 2
|
|
exceptions:
|
|
- condition: 'det_type == defs::EIGER || det_type == defs::MYTHEN3 || det_type == defs::GOTTHARD2 || det_type == defs::MOENCH'
|
|
message: '"dbitphase not implemented for this detector"'
|
|
- condition: 'args[1] != "deg"'
|
|
message: '"Unknown dbitphase 2nd argument " + args[1] + ". Did you mean deg? "'
|
|
function: setDBITPhaseInDegrees
|
|
arg_types: [ int, special::deg ]
|
|
output: [ 'args[0]',"' '", 'args[1]' ]
|
|
|
|
clkfreq:
|
|
help: "[n_clock] [freq_in_Hz]\n\t[Gotthard2][Mythen3] Frequency of clock n_clock in Hz. Use clkdiv to set frequency.\n\t[Gotthard2] Clock index range: 0-5\n\t[Mythen3] Clock index range: 0"
|
|
actions:
|
|
GET:
|
|
extra_variables:
|
|
- name: type
|
|
type: defs::detectorType
|
|
value: det->getDetectorType().squash(defs::GENERIC);
|
|
exceptions:
|
|
- condition: 'type != defs::GOTTHARD2 && type != defs::MYTHEN3'
|
|
message: '"clkfreq not implemented for this detector."'
|
|
argc: 1
|
|
require_det_id: true
|
|
function: getClockFrequency
|
|
input: [ 'args[0]' ]
|
|
input_types: [ int ]
|
|
cast_input: [ true ]
|
|
output: [ OutString(t) ]
|
|
|
|
clkphase:
|
|
help: "[n_clock] [phase] [deg (optional)]\n\t[Gotthard2][Mythen3] Phase of clock n_clock. If deg, then phase shift in degrees, else absolute phase shift values.n\t[Gotthard2] Clock index range: 0-5\n\t[Mythen3] Clock index range: 0"
|
|
actions:
|
|
GET:
|
|
extra_variables:
|
|
- name: type
|
|
type: defs::detectorType
|
|
value: det->getDetectorType().squash(defs::GENERIC);
|
|
exceptions:
|
|
- condition: 'type != defs::GOTTHARD2 && type != defs::MYTHEN3'
|
|
message: '"clkphase not implemented for this detector."'
|
|
require_det_id: true
|
|
input: [ 'args[0]' ]
|
|
input_types: [ int ]
|
|
cast_input: [ true ]
|
|
output: [ OutString(t) ]
|
|
args:
|
|
- argc: 1
|
|
function: getClockPhase
|
|
- argc: 2
|
|
exceptions:
|
|
- condition: 'type != defs::GOTTHARD2 && type != defs::MYTHEN3'
|
|
message: '"clkphase not implemented for this detector."'
|
|
- condition: 'args[1] != "deg"'
|
|
message: '"Cannot scan argument" + args[1] + ". Did you mean deg?"'
|
|
arg_types: [ int , special::deg ]
|
|
function: getClockPhaseinDegrees
|
|
output: [ OutString(t), '" deg"' ]
|
|
PUT:
|
|
extra_variables:
|
|
- name: type
|
|
type: defs::detectorType
|
|
value: det->getDetectorType().squash(defs::GENERIC);
|
|
exceptions:
|
|
- condition: 'type != defs::GOTTHARD2 && type != defs::MYTHEN3'
|
|
message: '"clkphase not implemented for this detector."'
|
|
require_det_id: true
|
|
input: [ 'args[0]', 'args[1]' ]
|
|
input_types: [ int, int ]
|
|
cast_input: [ true, true ]
|
|
args:
|
|
- argc: 2
|
|
function: setClockPhase
|
|
output: [ 'args[1]' ]
|
|
- argc: 3
|
|
arg_types: [int, int , special::deg ]
|
|
|
|
exceptions:
|
|
- condition: 'type != defs::GOTTHARD2 && type != defs::MYTHEN3'
|
|
message: '"clkphase not implemented for this detector."'
|
|
- condition: 'args[2] != "deg"'
|
|
message: '"Cannot scan argument" + args[2] + ". Did you mean deg?"'
|
|
function: setClockPhaseinDegrees
|
|
output: [ 'args[1]', '" "', 'args[2]' ]
|
|
|
|
maxclkphaseshift:
|
|
help: "[n_clock]\n\t[Gotthard2][Mythen3] Absolute Maximum Phase shift of clock n_clock.n\t[Gotthard2] Clock index range: 0-5\n\t[Mythen3] Clock index range: 0"
|
|
actions:
|
|
GET:
|
|
extra_variables:
|
|
- name: type
|
|
type: defs::detectorType
|
|
value: det->getDetectorType().squash(defs::GENERIC);
|
|
exceptions:
|
|
- condition: 'type != defs::GOTTHARD2 && type != defs::MYTHEN3'
|
|
message: '"maxclkphaseshift not implemented for this detector."'
|
|
require_det_id: true
|
|
input: [ 'args[0]' ]
|
|
input_types: [ int ]
|
|
cast_input: [ true ]
|
|
output: [ OutString(t) ]
|
|
argc: 1
|
|
function: getMaxClockPhaseShift
|
|
|
|
clkdiv:
|
|
help: "[n_clock] [n_divider]\n\t[Gotthard2][Mythen3] Clock Divider of clock n_clock. Must be greater than 1.\n\t[Gotthard2] Clock index range: 0-5\n\t[Mythen3] Clock index range: 0"
|
|
actions:
|
|
GET:
|
|
extra_variables:
|
|
- name: type
|
|
type: defs::detectorType
|
|
value: det->getDetectorType().squash(defs::GENERIC);
|
|
exceptions:
|
|
- condition: 'type != defs::GOTTHARD2 && type != defs::MYTHEN3'
|
|
message: '"clkdiv not implemented for this detector."'
|
|
require_det_id: true
|
|
function: getClockDivider
|
|
argc: 1
|
|
input: [ 'args[0]' ]
|
|
input_types: [ int ]
|
|
cast_input: [ true ]
|
|
output: [ 'args[0]', "' '", OutString(t) ]
|
|
PUT:
|
|
extra_variables:
|
|
- name: type
|
|
type: defs::detectorType
|
|
value: det->getDetectorType().squash(defs::GENERIC);
|
|
exceptions:
|
|
- condition: 'type != defs::GOTTHARD2 && type != defs::MYTHEN3'
|
|
message: '"clkdiv not implemented for this detector."'
|
|
require_det_id: true
|
|
function: setClockDivider
|
|
argc: 2
|
|
arg_types: [ int, int ]
|
|
input: [ 'args[0]', 'args[1]']
|
|
input_types: [ int, int ]
|
|
cast_input: [ true, true ]
|
|
output: [ 'args[0]', "' '", 'args[1]' ]
|
|
|
|
extsig:
|
|
help: "[n_signal] [signal_type]\n\t[Gotthard][Mythen3] External signal mode for trigger timing mode.\n\t[Gotthard] [0] [trigger_in_rising_edge|trigger_in_falling_edge]\n\t[Mythen3] [0-7] [trigger_in_rising_edge|trigger_in_falling_edge|inversion_on|inversion_off]\n\t where 0 is master input trigger signal, 1-3 is master input gate signals, 4 is busy out signal and 5-7 is master output gate signals."
|
|
actions:
|
|
GET:
|
|
argc: 1
|
|
require_det_id: true
|
|
function: getExternalSignalFlags
|
|
input: [ 'args[0]' ]
|
|
input_types: [ int ]
|
|
cast_input: [ true ]
|
|
output: [ "args[0]","' '", OutString(t) ]
|
|
PUT:
|
|
argc: 2
|
|
require_det_id: true
|
|
function: setExternalSignalFlags
|
|
input: [ 'args[0]', 'args[1]' ]
|
|
input_types: [ int, defs::externalSignalFlag ]
|
|
cast_input: [ true, true ]
|
|
output: [ 'args[0]', "' '", 'args[1]' ]
|
|
|
|
dac:
|
|
help: "code: return GetHelpDacWrapper(cmd, args);\n" # this is a special case
|
|
actions:
|
|
GET:
|
|
exceptions:
|
|
- condition: "is_int(args[0]) && det->getDetectorType().squash() != defs::CHIPTESTBOARD && det->getDetectorType().squash() != defs::XILINX_CHIPTESTBOARD"
|
|
message: '"Dac indices can only be used for chip test board. Use daclist to get list of dac names for current detector."'
|
|
extra_variables:
|
|
- name: dacIndex
|
|
type: defs::dacIndex
|
|
value: "((det->getDetectorType().squash() == defs::CHIPTESTBOARD || det->getDetectorType().squash() == defs::XILINX_CHIPTESTBOARD) && !is_int(args[0])) ? det->getDacIndex(args[0]) : StringTo<defs::dacIndex>(args[0])"
|
|
function: getDAC
|
|
require_det_id: true
|
|
input_types: [ defs::dacIndex, bool ]
|
|
cast_input: [ false, true ]
|
|
args:
|
|
- argc: 1
|
|
arg_types: [defs::dacIndex]
|
|
input: [ dacIndex, '"0"' ]
|
|
output: [ 'args[0]', "' '", OutString(t) ]
|
|
- argc: 2
|
|
exceptions:
|
|
- condition: "is_int(args[0]) && det->getDetectorType().squash() != defs::CHIPTESTBOARD && det->getDetectorType().squash() != defs::XILINX_CHIPTESTBOARD"
|
|
message: '"Dac indices can only be used for chip test board. Use daclist to get list of dac names for current detector."'
|
|
- condition: 'args[1] != "mv" && args[1] != "mV"'
|
|
message: '"Unknown argument " + args[1] + ". Did you mean mV?"'
|
|
arg_types: [defs::dacIndex, special::mv]
|
|
input: [ dacIndex, '"1"' ]
|
|
output: [ 'args[0]', "' '" , OutString(t), '" mV"' ]
|
|
PUT:
|
|
exceptions:
|
|
- condition: "is_int(args[0]) && det->getDetectorType().squash() != defs::CHIPTESTBOARD && det->getDetectorType().squash() != defs::XILINX_CHIPTESTBOARD"
|
|
message: '"Dac indices can only be used for chip test board. Use daclist to get list of dac names for current detector."'
|
|
extra_variables:
|
|
- name: dacIndex
|
|
type: defs::dacIndex
|
|
value: "((det->getDetectorType().squash() == defs::CHIPTESTBOARD || det->getDetectorType().squash() == defs::XILINX_CHIPTESTBOARD) && !is_int(args[0])) ? det->getDacIndex(args[0]) : StringTo<defs::dacIndex>(args[0])"
|
|
function: setDAC
|
|
require_det_id: true
|
|
input_types: [ defs::dacIndex, int, bool ]
|
|
cast_input: [ false, true, true ]
|
|
args:
|
|
- argc: 2
|
|
arg_types: [defs::dacIndex, int]
|
|
input: [ dacIndex, "args[1]", '"0"' ]
|
|
output: [ "args[0]", "' '", "args[1]" ]
|
|
- argc: 3
|
|
arg_types: [defs::dacIndex, int, special::mv]
|
|
input: [ dacIndex, "args[1]", '"1"' ]
|
|
output: [ "args[0]", "' '", "args[1]", '" mV"' ]
|
|
|
|
resetdacs:
|
|
help: "[(optional) hard] \n\t[Eiger][Jungfrau][Moench][Gotthard][Gotthard2][Mythen3]Reset dac values to the defaults. A 'hard' optional reset will reset the dacs to the hardcoded defaults in on-board detector server."
|
|
actions:
|
|
PUT:
|
|
function: resetToDefaultDacs
|
|
require_det_id: true
|
|
input_types: [ bool ]
|
|
output: [ '"successful"' ]
|
|
args:
|
|
- argc: 1
|
|
arg_types: [ special::hard ]
|
|
exceptions:
|
|
- condition: 'args[0] != "hard"'
|
|
message: '"Unknown argument " + args[0] + ". Did you mean hard?"'
|
|
input: [ '"1"' ]
|
|
- argc: 0
|
|
input: [ '"0"' ]
|
|
|
|
defaultdac:
|
|
help: "[dac name][value][(optional)setting]\n\tSets the default for that dac to this value.\n\t[Jungfrau][Moench][Mythen3] When settings is provided, it sets the default value only for that setting"
|
|
actions:
|
|
GET:
|
|
function: getDefaultDac
|
|
require_det_id: true
|
|
args:
|
|
- argc: 1
|
|
input: [ "args[0]" ]
|
|
cast_input: [ true ]
|
|
input_types: [ defs::dacIndex ]
|
|
output: [ "args[0]", "' '", OutString(t) ]
|
|
- argc: 2
|
|
input: [ "args[0]", "args[1]" ]
|
|
cast_input: [ true, true ]
|
|
input_types: [ defs::dacIndex, defs::detectorSettings ]
|
|
output: [ "args[0]", "' '", "args[1]", "' '", OutString(t) ]
|
|
PUT:
|
|
function: setDefaultDac
|
|
require_det_id: true
|
|
args:
|
|
- argc: 2
|
|
cast_input: [ true, true ]
|
|
input: [ "args[0]", "args[1]" ]
|
|
input_types: [ defs::dacIndex, int ]
|
|
output: [ "args[0]", "' '", "args[1]" ]
|
|
|
|
- argc: 3
|
|
cast_input: [ true, true, true ]
|
|
input: [ "args[0]", "args[1]", "args[2]" ]
|
|
input_types: [ defs::dacIndex, int, defs::detectorSettings ]
|
|
output: [ "args[0]", "' '", "args[2]", "' '", "args[1]" ]
|
|
|
|
rx_status:
|
|
help: "[running, idle, transmitting]\n\tReceiver listener status."
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
function: getReceiverStatus
|
|
require_det_id: true
|
|
output: [ OutString(t) ]
|
|
PUT:
|
|
argc: -1
|
|
exceptions:
|
|
- condition: 'true'
|
|
message: '"Cannot put. Did you mean to use command: \"rx_start\" or \"rx_stop\"?"'
|
|
|
|
status:
|
|
help: "[running, error, transmitting, finished, waiting, idle]\n\tDetector status. Goes to stop server."
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
function: getDetectorStatus
|
|
require_det_id: true
|
|
output: [ OutString(t) ]
|
|
PUT:
|
|
argc: -1
|
|
exceptions:
|
|
- condition: 'true'
|
|
message: '"Cannot put. Did you mean to use command: \"start\" or \"stop\"?"'
|
|
|
|
|
|
scan:
|
|
help: "[dac_name|0|trimbits] [start_val] [stop_val] [step_size] [dac settling time ns|us|ms|s]\n\tEnables/ disables scans for dac and trimbits \n\tEnabling scan sets number of frames to number of steps in receiver. \n\tTo cancel scan configuration, set dac to '0', which also sets number of frames to 1. \n\t[Eiger][Mythen3] Use trimbits as dac name for a trimbit scan."
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
function: getScan
|
|
require_det_id: true
|
|
output: [ OutString(t) ]
|
|
PUT:
|
|
check_det_id: true
|
|
function: setScan
|
|
output: [ ToString(args) ]
|
|
args:
|
|
- argc: 1
|
|
exceptions:
|
|
- condition: 'StringTo<int>(args[0]) != 0'
|
|
message: '"Unknown argument " + args[0] + ". Did you mean 0 to disable scan?"'
|
|
arg_types: [ int ]
|
|
input: [ "defs::scanParameters()" ]
|
|
input_types: [ auto ]
|
|
- argc: 4
|
|
arg_types: [ defs::dacIndex, int, int, int ]
|
|
input: [ "defs::scanParameters(StringTo<defs::dacIndex>(args[0]), StringTo<int>(args[1]), StringTo<int>(args[2]), StringTo<int>(args[3]))" ]
|
|
input_types: [ auto ]
|
|
- argc: 5
|
|
arg_types: [ defs::dacIndex, int, int, int, std::string ]
|
|
separate_time_units:
|
|
input: 'args[4]'
|
|
output: [ t, unit ]
|
|
input: [ "defs::scanParameters(StringTo<defs::dacIndex>(args[0]), StringTo<int>(args[1]), StringTo<int>(args[2]), StringTo<int>(args[3]), t)" ]
|
|
input_types: [ auto ]
|
|
|
|
Trigger:
|
|
template: true
|
|
actions:
|
|
PUT:
|
|
check_det_id: true
|
|
argc: 0
|
|
function: sendSoftwareTrigger
|
|
input: [ block ]
|
|
input_types: [ bool ]
|
|
cast_input: [ false ]
|
|
output: [ '"successful"' ]
|
|
|
|
trigger:
|
|
inherit_actions: Trigger
|
|
help: "\n\t[Eiger][Mythen3][Jungfrau][Moench] Sends software trigger signal to detector"
|
|
actions:
|
|
PUT:
|
|
extra_variables:
|
|
- name: block
|
|
type: bool
|
|
value: "false"
|
|
|
|
blockingtrigger:
|
|
inherit_actions: Trigger
|
|
help: "\n\t[Eiger][Jungfrau][Moench] Sends software trigger signal to detector and blocks till the frames are sent out for that trigger."
|
|
actions:
|
|
PUT:
|
|
extra_variables:
|
|
- name: block
|
|
type: bool
|
|
value: "true"
|
|
|
|
udp_dstlist:
|
|
help: "[ip=x.x.x.x] [(optional)ip2=x.x.x.x] \n\t\t[mac=xx:xx:xx:xx:xx:xx] [(optional)mac2=xx:xx:xx:xx:xx:xx]\n\t\t[port=value] [(optional)port2=value]\n\t\tThe order of ip, mac and port does not matter. entry_value can be >0 only for [Eiger][Jungfrau][Moench][Mythen3][Gotthard2] where round robin is implemented. If 'auto' used, then ip is set to ip of rx_hostname."
|
|
actions:
|
|
GET:
|
|
exceptions:
|
|
- condition: "det_id == -1"
|
|
message: '"Can execute udp_dstlist only at module level."'
|
|
- condition: "rx_id < 0 || rx_id >= MAX_UDP_DESTINATION"
|
|
message: '"Invalid receiver index " + std::to_string(rx_id) + " to set round robin entry."'
|
|
argc: 0
|
|
function: getDestinationUDPList
|
|
require_det_id: true
|
|
input: [ rx_id ]
|
|
input_types: [ auto ]
|
|
output: [ OutString(t) ]
|
|
PUT:
|
|
exceptions:
|
|
- condition: "det_id == -1"
|
|
message: '"Can execute udp_dstlist only at module level."'
|
|
- condition: "rx_id < 0 || rx_id >= MAX_UDP_DESTINATION"
|
|
message: '"Invalid receiver index " + std::to_string(rx_id) + " to set round robin entry."'
|
|
- condition: "args.empty()"
|
|
message: '"udp_dstlist require at least one argument."'
|
|
argc: -1
|
|
function: setDestinationUDPList
|
|
require_det_id: true
|
|
convert_det_id: false
|
|
arg_types: [ std::string ]
|
|
input: [ getUdpEntry() ]
|
|
input_types: [ auto ]
|
|
output: [ ToString(args) ]
|
|
|
|
txdelay:
|
|
help: "[n_delay]\n\t[Eiger][Jungfrau][Moench][Mythen3] Set transmission delay for all modules in the detector using the step size provided.Sets up \n\t[Eiger] txdelay_left to (2 * mod_index * n_delay), \n\t[Eiger] txdelay_right to ((2 * mod_index + 1) * n_delay) and \n\t[Eiger] txdelay_frame to (2 *num_modules * n_delay)\n\t[Jungfrau][Moench][Mythen3] txdelay_frame to (num_modules * n_delay) for every module."
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
check_det_id: true
|
|
function: getTransmissionDelay
|
|
output: [ OutString(t) ]
|
|
PUT:
|
|
argc: 1
|
|
check_det_id: true
|
|
function: setTransmissionDelay
|
|
input: [ 'args[0]' ]
|
|
input_types: [ int ]
|
|
cast_input: [ true ]
|
|
output: [ 'args.front()' ]
|
|
|
|
zmqhwm:
|
|
help: "[n_limit] \n\tClient's zmq receive high water mark. Default is the zmq library's default (1000), can also be set here using -1. \n\tThis is a high number and can be set to 2 for gui purposes. \n\tOne must also set the receiver's send high water mark to similar value. Final effect is sum of them.\n\t Setting it via command line is useful only before zmq enabled (before opening gui)."
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
function: getClientZmqHwm
|
|
output: [ t ]
|
|
PUT:
|
|
argc: 1
|
|
function: setClientZmqHwm
|
|
input: [ 'args[0]' ]
|
|
input_types: [ int ]
|
|
cast_input: [ true ]
|
|
output: [ 'det->getClientZmqHwm()' ]
|
|
|
|
Pulse:
|
|
template: true
|
|
help: ''
|
|
actions:
|
|
PUT:
|
|
argc: 3
|
|
require_det_id: true
|
|
function: ''
|
|
arg_types: [int, int, int]
|
|
extra_variables:
|
|
- name: c
|
|
type: defs::xy
|
|
value: defs::xy(StringTo<int>(args[1]), StringTo<int>(args[2]))
|
|
input: [ 'args[0]', c ]
|
|
input_types: [ int, defs::xy ]
|
|
cast_input: [ true, false ]
|
|
output: [ ToString(args) ]
|
|
|
|
pulse:
|
|
inherit_actions: Pulse
|
|
help: "[n_times] [x] [y]\n\t[Eiger] Pulse pixel n number of times at coordinates (x, y). Advanced User!"
|
|
actions:
|
|
PUT:
|
|
function: pulsePixel
|
|
|
|
pulsenmove:
|
|
inherit_actions: Pulse
|
|
help: "[n_times] [x] [y]\n\t[Eiger] Pulse pixel n number of times and moves relatively by (x, y). Advanced User!"
|
|
actions:
|
|
PUT:
|
|
function: pulsePixelNMove
|
|
|
|
pulsechip:
|
|
help: "[n_times] \n\t[Eiger] Pulse chip n times. If n is -1, resets to normal mode (reset chip completely at start of acquisition, where partialreset = 0). Advanced User!"
|
|
actions:
|
|
PUT:
|
|
argc: 1
|
|
require_det_id: true
|
|
function: pulseChip
|
|
input: [ 'args[0]' ]
|
|
input_types: [ int ]
|
|
cast_input: [ true ]
|
|
output: [ args.front() ]
|
|
|
|
quad:
|
|
help: "[0, 1]\n\t[Eiger] Sets detector size to a quad. 0 (disabled) is default. (Specific hardware required)."
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
require_det_id: true
|
|
function: getQuad
|
|
output: [ OutString(t) ]
|
|
PUT:
|
|
argc: 1
|
|
check_det_id: true
|
|
function: setQuad
|
|
input: [ 'args[0]' ]
|
|
input_types: [ bool ]
|
|
cast_input: [ true ]
|
|
output: [ args.front() ]
|
|
|
|
datastream:
|
|
help: "[left|right] [0, 1]\n\t[Eiger] Enables or disables data streaming from left or/and right side of detector for 10 GbE mode. 1 (enabled) by default."
|
|
actions:
|
|
GET:
|
|
argc: 1
|
|
require_det_id: true
|
|
function: getDataStream
|
|
input: [ 'args[0]' ]
|
|
input_types: [ defs::portPosition ]
|
|
cast_input: [ true ]
|
|
output: [ OutString(t) ]
|
|
PUT:
|
|
argc: 2
|
|
require_det_id: true
|
|
function: setDataStream
|
|
input: [ 'args[0]', 'args[1]' ]
|
|
input_types: [ defs::portPosition, bool ]
|
|
cast_input: [ true, true ]
|
|
output: [ 'ToString(args)' ]
|
|
|
|
temp_event:
|
|
help: "[0]\n\t[Jungfrau][Moench] 1, if a temperature event occured. To clear this event, set it to 0.\n\tIf temperature crosses threshold temperature and temperature control is enabled, power to chip will be switched off and temperature event occurs. To power on chip again, temperature has to be less than threshold temperature and temperature event has to be cleared."
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
require_det_id: true
|
|
function: getTemperatureEvent
|
|
output: [ OutString(t) ]
|
|
PUT:
|
|
argc: 1
|
|
exceptions:
|
|
- condition: 'StringTo<int>(args[0]) != 0'
|
|
message: '"Unknown argument for temp event: ( " + args[0] + " ). Did you mean 0 to reset event?"'
|
|
require_det_id: true
|
|
function: resetTemperatureEvent
|
|
arg_types: [ int ]
|
|
output: [ '"cleared"' ]
|
|
|
|
pedestalmode:
|
|
help: " [frames<uint8_t>] [loops<uint16_t>]\n\t\t[Jungfrau] Enable pedestal mode. \n\t\tThe number of frames or triggers is overwritten by: \n\t\t(#pedestal_frames x #pedestal_loops x 2). \n\t\tIn auto timing mode or in trigger mode with #frames > 1, \n\t\t#frames is overwritten and #triggers = 1, \n\t\telse #triggers is overwritten and #frames = 1. \n\t\tOne cannot set #frames, #triggers or timing mode in pedestal mode (exception thrown).\n\tpedestalmode [0]\n\t\t[Jungfrau] Disable pedestal mode.\n\t\tDisabling pedestal mode will set back the normal mode values of #frames and #triggers."
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
require_det_id: true
|
|
function: getPedestalMode
|
|
output: [ OutString(t) ]
|
|
PUT:
|
|
function: setPedestalMode
|
|
output: [ "ToString(args)" ]
|
|
args:
|
|
- argc: 1
|
|
exceptions:
|
|
- condition: 'args[0] != "0"'
|
|
message: '"Unknown argument " + args[0] + ". Did you mean 0 to disable pedestal mode?"'
|
|
arg_types: [ special::pedestal_parameters ]
|
|
input: [ defs::pedestalParameters() ]
|
|
input_types: [ defs::pedestalParameters ]
|
|
- argc: 2
|
|
arg_types: [ uint8_t, uint16_t ]
|
|
input_types: [ defs::pedestalParameters ]
|
|
input: [ 'defs::pedestalParameters(StringTo<uint8_t>(args[0]), StringTo<uint16_t>(args[1]))' ]
|
|
|
|
roi:
|
|
help: "[xmin] [xmax] \n\t[Gotthard] Region of interest in detector.\n\tOptions: Only a single ROI per module. \n\tEither all channels or a single adc or 2 chips (256 channels). Default is all channels enabled (-1 -1). "
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
require_det_id: true
|
|
function: getROI
|
|
output: [ t ]
|
|
PUT:
|
|
argc: 2
|
|
exceptions:
|
|
- condition: 'det_id == -1 && det->size() > 1'
|
|
message: '"Cannot execute ROI at multi module level"'
|
|
require_det_id: true
|
|
convert_det_id: false
|
|
function: setROI
|
|
arg_types: [ int, int ]
|
|
extra_variables:
|
|
- name: t
|
|
type: defs::ROI
|
|
value: defs::ROI(StringTo<int>(args[0]), StringTo<int>(args[1]))
|
|
input: [ t ]
|
|
input_types: [ defs::ROI ]
|
|
output: [ 't' ]
|
|
|
|
inj_ch:
|
|
help: "[offset] [increment]\n\t[Gotthard2] Inject channels with current source for calibration. Offset is starting channel that is injected, increment determines succeeding channels to be injected."
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
require_det_id: true
|
|
function: getInjectChannel
|
|
output: [ OutString(t) ]
|
|
PUT:
|
|
argc: 2
|
|
function: setInjectChannel
|
|
require_det_id: true
|
|
arg_types: [int, int]
|
|
input: [ 'args[0]', 'args[1]' ]
|
|
input_types: [ int, int ]
|
|
cast_input: [ true, true ]
|
|
output: [ ToString(args) ]
|
|
|
|
vetophoton:
|
|
help: "[ichip] [#photons] [energy in keV] [reference file]\n\t[Gotthard2] Set veto reference for 128 channels for chip ichip according to reference file and #photons and energy in keV.\n\t[ichip] [output file]\n\t Get gain indices and veto reference for 128 channels for chip ichip, saved to file."
|
|
actions:
|
|
GET:
|
|
argc: 2
|
|
require_det_id: true
|
|
function: getVetoPhoton
|
|
store_result_in_t: false
|
|
input: [ 'args[0]', 'args[1]' ]
|
|
input_types: [ int, std::string ]
|
|
cast_input: [ true, false ]
|
|
output: [ '"saved to file "' , "args[1]" ]
|
|
PUT:
|
|
argc: 4
|
|
require_det_id: true
|
|
function: setVetoPhoton
|
|
input: [ 'args[0]', 'args[1]', "args[2]", "args[3]" ]
|
|
input_types: [ int, int, int, std::string ]
|
|
cast_input: [ true, true, true, false ]
|
|
output: [ ToString(args) ]
|
|
|
|
vetoref:
|
|
help: "[gain index] [12 bit value]\n\t[Gotthard2] Set veto reference for all 128 channels for all chips."
|
|
actions:
|
|
GET:
|
|
argc: -1
|
|
exceptions:
|
|
- condition: 'true'
|
|
message: '"Cannot get vetoref. Did you mean vetophoton?"'
|
|
|
|
PUT:
|
|
argc: 2
|
|
function: setVetoReference
|
|
input: [ 'args[0]', 'args[1]' ]
|
|
input_types: [ int, int ]
|
|
cast_input: [ true, true ]
|
|
output: [ ToString(args) ]
|
|
|
|
vetofile:
|
|
help: "[chip index 0-9, -1 for all] [file name] \n\t[Gotthard2] Set veto reference for each 128 channels for specific chip. The file should have 128 rows of gain index and 12 bit value in dec"
|
|
actions:
|
|
GET:
|
|
argc: -1
|
|
exceptions:
|
|
- condition: 'true'
|
|
message: '"Cannot get vetofile. Did you mean vetophoton?"'
|
|
PUT:
|
|
argc: 2
|
|
function: setVetoFile
|
|
require_det_id: true
|
|
input: [ 'args[0]', 'args[1]' ]
|
|
input_types: [ int, std::string ]
|
|
cast_input: [ true, false ]
|
|
output: [ ToString(args) ]
|
|
|
|
vetoalg:
|
|
help: "[hits|raw] [lll|10gbe]\n\t[Gotthard2] Set the veto algorithm. Default is hits."
|
|
actions:
|
|
GET:
|
|
argc: 1
|
|
extra_variables:
|
|
- name: interface
|
|
type: defs::streamingInterface
|
|
value: StringTo<defs::streamingInterface>(args[0])
|
|
exceptions:
|
|
- condition: 'interface == defs::streamingInterface::NONE'
|
|
message: '"Must specify an interface to set algorithm"'
|
|
require_det_id: true
|
|
function: getVetoAlgorithm
|
|
input: [ 'interface' ]
|
|
input_types: [ defs::streamingInterface ]
|
|
cast_input: [ false ]
|
|
output: [ OutString(t), "' '", ToString(interface) ]
|
|
PUT:
|
|
argc: 2
|
|
extra_variables:
|
|
- name: alg
|
|
type: defs::vetoAlgorithm
|
|
value: StringTo<defs::vetoAlgorithm>(args[0])
|
|
- name: interface
|
|
type: defs::streamingInterface
|
|
value: StringTo<defs::streamingInterface>(args[1])
|
|
exceptions:
|
|
- condition: 'interface == defs::streamingInterface::NONE'
|
|
message: '"Must specify an interface to set algorithm"'
|
|
require_det_id: true
|
|
function: setVetoAlgorithm
|
|
input: [ 'alg', 'interface' ]
|
|
input_types: [ defs::vetoAlgorithm, defs::streamingInterface ]
|
|
cast_input: [ false, false ]
|
|
output: [ ToString(alg), "' '", ToString(interface) ]
|
|
|
|
confadc:
|
|
help: "[chip index 0-9, -1 for all] [adc index 0-31, -1 for all] [7 bit configuration value in hex]\n\t[Gotthard2] Sets configuration for specific chip and adc, but configures 1 chip (all adcs for that chip) at a time."
|
|
actions:
|
|
GET:
|
|
argc: 2
|
|
require_det_id: true
|
|
function: getADCConfiguration
|
|
input: [ 'args[0]', 'args[1]' ]
|
|
input_types: [ int, int ]
|
|
cast_input: [ true, true ]
|
|
output: [ OutStringHex(t) ]
|
|
PUT:
|
|
argc: 3
|
|
require_det_id: true
|
|
function: setADCConfiguration
|
|
input: [ 'args[0]', 'args[1]', 'args[2]' ]
|
|
input_types: [ int, int, int ]
|
|
cast_input: [ true, true, true ]
|
|
output: [ "'['", "args[0]", '", "', "args[1]", '", "', "ToStringHex( StringTo<int>(args[2]))", '"]"' ]
|
|
|
|
gatedelay:
|
|
help: "[duration] [(optional unit) ns|us|ms|s]\n\t[Mythen3] Gate Delay of all gate signals in auto and trigger mode (internal gating)."
|
|
actions:
|
|
GET:
|
|
function: getGateDelayForAllGates
|
|
require_det_id: true
|
|
args:
|
|
- argc: 0
|
|
output: [ OutString(t) ]
|
|
- argc: 1
|
|
arg_types: [ special::time_unit ]
|
|
output: [ "OutString(t, args[0])" ]
|
|
PUT:
|
|
extra_variables:
|
|
- name: gateIndex
|
|
type: int
|
|
value: -1
|
|
require_det_id: true
|
|
function: setGateDelay
|
|
input: [ gateIndex, converted_time ]
|
|
input_types: [ int, time::ns ]
|
|
args:
|
|
- argc: 1
|
|
arg_types: [ std::string ]
|
|
separate_time_units:
|
|
input: 'args[0]'
|
|
output: [ converted_time, unit ]
|
|
output: [ 'args[0]' ]
|
|
- argc: 2
|
|
arg_types: [ int, special::time_unit ]
|
|
convert_to_time:
|
|
input: [ 'args[0]', 'args[1]' ]
|
|
output: converted_time
|
|
output: [ 'args[0]', 'args[1]' ]
|
|
|
|
gatedelay1:
|
|
help: "[duration] [(optional unit) ns|us|ms|s]\n\t[Mythen3] Gate Delay of gate signal 1 in auto and trigger mode (internal gating)."
|
|
inherit_actions: gatedelay
|
|
actions:
|
|
GET:
|
|
extra_variables:
|
|
- name: gateIndex
|
|
type: int
|
|
value: 0
|
|
function: getGateDelay
|
|
input: [ gateIndex ]
|
|
input_types: [ int ]
|
|
PUT:
|
|
extra_variables:
|
|
- name: gateIndex
|
|
type: int
|
|
value: 0
|
|
|
|
gatedelay2:
|
|
help: "[duration] [(optional unit) ns|us|ms|s]\n\t[Mythen3] Gate Delay of gate signal 2 in auto and trigger mode (internal gating)."
|
|
inherit_actions: gatedelay1
|
|
actions:
|
|
GET:
|
|
extra_variables:
|
|
- name: gateIndex
|
|
type: int
|
|
value: 1
|
|
PUT:
|
|
extra_variables:
|
|
- name: gateIndex
|
|
type: int
|
|
value: 1
|
|
|
|
gatedelay3:
|
|
help: "[duration] [(optional unit) ns|us|ms|s]\n\t[Mythen3] Gate Delay of gate signal 3 in auto and trigger mode (internal gating)."
|
|
inherit_actions: gatedelay1
|
|
actions:
|
|
GET:
|
|
extra_variables:
|
|
- name: gateIndex
|
|
type: int
|
|
value: 2
|
|
PUT:
|
|
extra_variables:
|
|
- name: gateIndex
|
|
type: int
|
|
value: 2
|
|
|
|
adcvpp:
|
|
help: "[dac or mV value][(optional unit) mV] \n\t[Ctb] Vpp of ADC.\n\t 0 -> 1V ; 1 -> 1.14V ; 2 -> 1.33V ; 3 -> 1.6V ; 4 -> 2V. \n\tAdvanced User function!"
|
|
actions:
|
|
GET:
|
|
require_det_id: true
|
|
function: getADCVpp
|
|
args:
|
|
- argc: 0
|
|
input: [ '"0"' ]
|
|
input_types: [ bool ]
|
|
cast_input: [ true ]
|
|
output: [ OutString(t) ]
|
|
- argc: 1
|
|
arg_type: [ special::mv ]
|
|
exceptions:
|
|
- condition: '(args[0] != "mv") && (args[0] != "mV")'
|
|
message: '"Unknown argument " + args[0] + ". Did you mean mV?"'
|
|
input: [ '"1"' ]
|
|
input_types: [ bool ]
|
|
cast_input: [ true ]
|
|
output: [ OutString(t), '" mV"' ]
|
|
PUT:
|
|
require_det_id: true
|
|
function: setADCVpp
|
|
args:
|
|
- argc: 1
|
|
output: [ "args[0]" ]
|
|
input: [ "args[0]", '"0"' ]
|
|
input_types: [ int, bool ]
|
|
arg_types: [ int ]
|
|
cast_input: [ true, true ]
|
|
- argc: 2
|
|
arg_types: [ int, special::mv ]
|
|
exceptions:
|
|
- condition: '(args[1] != "mv") && (args[1] != "mV")'
|
|
message: '"Unknown argument " + args[1] + ". Did you mean mV?"'
|
|
input: [ "args[0]", '"1"' ]
|
|
input_types: [ int, bool ]
|
|
cast_input: [ true , true ]
|
|
output: [ "args[0]", '" mV"' ]
|
|
|
|
diodelay:
|
|
help: "[0-775]\n\t[Ctb] Delay for diode. Delay is in ps and max of 775 ps. Resolution is 25 ps."
|
|
actions:
|
|
PUT:
|
|
argc: 2
|
|
require_det_id: true
|
|
function: setDigitalIODelay
|
|
input: [ 'args[0]', 'args[1]' ]
|
|
input_types: [ uint64_t, int ]
|
|
cast_input: [ true, true ]
|
|
output: [ ToString(args) ]
|
|
|
|
# pattern is a keyword in yaml, so patternX is used to avoid it
|
|
patternX:
|
|
help: "[fname]\n\t[Mythen3][Ctb][Xilinx Ctb] Loads ASCII pattern file directly to server (instead of executing line by line)"
|
|
command_name: "pattern"
|
|
actions:
|
|
PUT:
|
|
argc: 1
|
|
require_det_id: true
|
|
function: setPattern
|
|
input: [ 'args[0]' ]
|
|
input_types: [ std::string ]
|
|
cast_input: [ false ]
|
|
output: [ 'args.front()' ]
|
|
|
|
patword:
|
|
help: "[step or address] [64 bit mask]\n\t[Ctb][Mythen3][Xilinx Ctb] 64 bit pattern at address of pattern memory.\n\t[Ctb] read is same as executing pattern"
|
|
actions:
|
|
GET:
|
|
argc: 1
|
|
require_det_id: true
|
|
function: getPatternWord
|
|
input: [ 'args[0]' ]
|
|
input_types: [ int ]
|
|
cast_input: [ true ]
|
|
output: [ "'['","ToStringHex(arg0, 4)", '", "', "OutStringHex(t, 16)", '"]"' ]
|
|
PUT:
|
|
argc: 2
|
|
require_det_id: true
|
|
function: setPatternWord
|
|
input: [ 'args[0]', 'args[1]' ]
|
|
input_types: [ int, uint64_t ]
|
|
cast_input: [ true, true ]
|
|
output: [ "'['", "ToStringHex(arg0, 4)", '", "', "ToStringHex(arg1, 16)", '"]"' ]
|
|
|
|
patlimits:
|
|
help: "[start addr] [stop addr] \n\t[Ctb][Mythen3][Xilinx Ctb] Limits of complete pattern"
|
|
actions:
|
|
GET:
|
|
argc: -1
|
|
require_det_id: true
|
|
function: getPatternLoopAddresses
|
|
input: [ '"-1"' ]
|
|
input_types: [ int ]
|
|
cast_input: [ true ]
|
|
output: [ "OutStringHex(t, 4)" ]
|
|
PUT:
|
|
argc: -1
|
|
require_det_id: true
|
|
function: setPatternLoopAddresses
|
|
input: [ '"-1"', 'args[0]', 'args[1]' ]
|
|
input_types: [ int, int, int ]
|
|
cast_input: [ true, true, true ]
|
|
output: [ "'['" , "ToStringHex(arg1, 4)" , '", "' , "ToStringHex(arg2, 4)", "']'" ]
|
|
|
|
patloop:
|
|
help: "[0-6] [start addr] [stop addr] \n\t[Ctb][Mythen3][Xilinx Ctb] Limits of the loop level provided.\n\t[Mythen3] Level options: 0-3 only."
|
|
actions:
|
|
GET:
|
|
argc: -1
|
|
pattern_command:
|
|
command_name: patloop
|
|
nGetArgs: 0
|
|
nPutArgs: 2
|
|
require_det_id: true
|
|
function: getPatternLoopAddresses
|
|
input: [ level ]
|
|
input_types: [ int ]
|
|
cast_input: [ false ]
|
|
output: [level,"' '" ,"OutStringHex(t, 4)" ]
|
|
PUT:
|
|
argc: -1
|
|
extra_variables:
|
|
- name: start
|
|
type: int
|
|
value: "StringTo<int>(args[iArg++])"
|
|
- name: stop
|
|
type: int
|
|
value: "StringTo<int>(args[iArg++])"
|
|
pattern_command:
|
|
command_name: patloop
|
|
nGetArgs: 0
|
|
nPutArgs: 2
|
|
require_det_id: true
|
|
function: setPatternLoopAddresses
|
|
input: [ level, start, stop ]
|
|
input_types: [ int, int, int ]
|
|
output: [level,"' '" , "'['" , "ToStringHex(start, 4)" , '", "' , "ToStringHex(stop, 4)", "']'" ]
|
|
|
|
patloop0:
|
|
help: "\n\tDeprecated command. Use patloop."
|
|
inherit_actions: patloop
|
|
actions:
|
|
GET:
|
|
output: ["OutStringHex(t, 4)" ]
|
|
PUT:
|
|
output: [ "'['" , "ToStringHex(start, 4)" , '", "' , "ToStringHex(stop, 4)", "']'" ]
|
|
|
|
patloop1:
|
|
inherit_actions: patloop0
|
|
|
|
patloop2:
|
|
inherit_actions: patloop0
|
|
|
|
patnloop:
|
|
help: "[0-6] [n_cycles] \n\t[Ctb][Mythen3][Xilinx Ctb] Number of cycles of the loop level provided.\n\t[Mythen3] Level options: 0-3 only."
|
|
actions:
|
|
GET:
|
|
argc: -1
|
|
pattern_command:
|
|
command_name: patnloop
|
|
nGetArgs: 0
|
|
nPutArgs: 1
|
|
require_det_id: true
|
|
function: getPatternLoopCycles
|
|
input: [ level ]
|
|
input_types: [ int ]
|
|
cast_input: [ false ]
|
|
output: [ level,"' '" , "OutString(t)" ]
|
|
PUT:
|
|
argc: -1
|
|
extra_variables:
|
|
- name: nloops
|
|
type: std::string
|
|
value: "args[iArg++]"
|
|
pattern_command:
|
|
command_name: patnloop
|
|
nGetArgs: 0
|
|
nPutArgs: 1
|
|
require_det_id: true
|
|
function: setPatternLoopCycles
|
|
input: [ level, nloops ]
|
|
input_types: [ int, int ]
|
|
cast_input: [ false, true ]
|
|
output: [ level,"' '" , nloops ]
|
|
|
|
patnloop0:
|
|
help: "\n\tDeprecated command. Use patnloop."
|
|
inherit_actions: patnloop
|
|
actions:
|
|
GET:
|
|
output: [ "OutString(t)" ]
|
|
PUT:
|
|
output: [ "nloops" ]
|
|
|
|
patnloop1:
|
|
inherit_actions: patnloop0
|
|
|
|
patnloop2:
|
|
inherit_actions: patnloop0
|
|
|
|
patwait:
|
|
help: "[0-6] [addr] \n\t[Ctb][Mythen3][Xilinx Ctb] Wait address for loop level provided. \n\t[Mythen3] Level options: 0-3 only."
|
|
actions:
|
|
GET:
|
|
argc: -1
|
|
pattern_command:
|
|
command_name: patwait
|
|
nGetArgs: 0
|
|
nPutArgs: 1
|
|
require_det_id: true
|
|
function: getPatternWaitAddr
|
|
input: [ level ]
|
|
input_types: [ int ]
|
|
cast_input: [ false ]
|
|
output: [level,"' '" , "OutStringHex(t, 4)" ]
|
|
PUT:
|
|
argc: -1
|
|
extra_variables:
|
|
- name: addr
|
|
type: int
|
|
value: "StringTo<int>(args[iArg++])"
|
|
pattern_command:
|
|
command_name: patwait
|
|
nGetArgs: 0
|
|
nPutArgs: 1
|
|
require_det_id: true
|
|
function: setPatternWaitAddr
|
|
input: [ level, addr ]
|
|
input_types: [ int, int ]
|
|
output: [level,"' '" , "ToStringHex(addr, 4)" ]
|
|
|
|
patwait0:
|
|
help: "\n\tDeprecated command. Use patwait."
|
|
inherit_actions: patwait
|
|
actions:
|
|
GET:
|
|
output: [ "OutStringHex(t, 4)" ]
|
|
PUT:
|
|
output: [ "ToStringHex(addr, 4)" ]
|
|
|
|
patwait1:
|
|
inherit_actions: patwait0
|
|
|
|
patwait2:
|
|
inherit_actions: patwait0
|
|
|
|
patwaittime:
|
|
help: "[0-6] [n_clk] \n\t[Ctb][Mythen3][Xilinx Ctb] Wait time in clock cycles for the loop provided.\n\t[Mythen3] Level options: 0-3 only."
|
|
actions:
|
|
GET:
|
|
argc: -1
|
|
pattern_command:
|
|
command_name: patwaittime
|
|
nGetArgs: 0
|
|
nPutArgs: 1
|
|
require_det_id: true
|
|
function: getPatternWaitTime
|
|
input: [ level ]
|
|
input_types: [ int ]
|
|
cast_input: [ false ]
|
|
output: [ level,"' '" , "OutString(t)" ]
|
|
PUT:
|
|
argc: -1
|
|
extra_variables:
|
|
- name: waittime
|
|
type: uint64_t
|
|
value: "StringTo<uint64_t>(args[iArg++])"
|
|
pattern_command:
|
|
command_name: patwaittime
|
|
nGetArgs: 0
|
|
nPutArgs: 1
|
|
require_det_id: true
|
|
function: setPatternWaitTime
|
|
input: [ level, waittime ]
|
|
input_types: [ int, int ]
|
|
output: [level,"' '" , "waittime" ]
|
|
|
|
patwaittime0:
|
|
help: "\n\tDeprecated command. Use patwaittime."
|
|
inherit_actions: patwaittime
|
|
actions:
|
|
GET:
|
|
output: [ "OutString(t)" ]
|
|
PUT:
|
|
output: [ "waittime" ]
|
|
|
|
patwaittime1:
|
|
inherit_actions: patwaittime0
|
|
|
|
patwaittime2:
|
|
inherit_actions: patwaittime0
|
|
|
|
rx_jsonpara:
|
|
help: "[key1] [value1]\n\t[Receiver] Additional json header parameter streamed out from receiver. If not found in header, the pair is appended. An empty values deletes parameter. Max 20 characters for each key/value."
|
|
actions:
|
|
GET:
|
|
argc: 1
|
|
require_det_id: true
|
|
function: getAdditionalJsonParameter
|
|
input: [ 'args[0]' ]
|
|
input_types: [ std::string ]
|
|
output: [ OutString(t) ]
|
|
PUT:
|
|
require_det_id: true
|
|
function: setAdditionalJsonParameter
|
|
args:
|
|
- argc: 1
|
|
input: [ 'args[0]', '""' ]
|
|
arg_types: [ std::string ]
|
|
input_types: [ std::string, std::string ]
|
|
cast_input: [ false, false ]
|
|
output: [ 'args[0]', '" deleted"' ]
|
|
- argc: 2
|
|
input: [ 'args[0]', 'args[1]' ]
|
|
input_types: [ std::string, std::string ]
|
|
cast_input: [ false, false ]
|
|
output: [ '"{"', 'args[0]', '": "', 'args[1]', '"}"' ]
|
|
|
|
programfpga:
|
|
help: "[fname.pof | fname.rbf (full path)][(opitonal)--force-delete-normal-file]\n\t[Jungfrau][Moench][Ctb] Programs FPGA from pof file (full path). Then, detector controller is rebooted. \n\t\tUse --force-delete-normal-file argument, if normal file found in device tree, it must be deleted, a new device drive created and programming continued.\n\t[Mythen3][Gotthard2] Programs FPGA from rbf file (full path). Then, detector controller is rebooted."
|
|
actions:
|
|
PUT:
|
|
require_det_id: true
|
|
function: programFPGA
|
|
output: [ '"successful"' ]
|
|
args:
|
|
- argc: 1
|
|
input: [ 'args[0]', '"0"' ]
|
|
input_types: [ std::string, bool ]
|
|
arg_types: [special::path]
|
|
cast_input: [ false, true ]
|
|
- argc: 2
|
|
arg_types: [special::path, special::force-delete-normal-file]
|
|
exceptions:
|
|
- condition: 'args[1] != "--force-delete-normal-file"'
|
|
message: '"Could not scan second argument. Did you mean --force-delete-normal-file?"'
|
|
input: [ 'args[0]', '"1"' ]
|
|
input_types: [ std::string, bool ]
|
|
cast_input: [ false, true ]
|
|
|
|
updatedetectorserver:
|
|
help: "[server_name with full path]\n\t[Jungfrau][Moench][Eiger][Ctb][Mythen3][Gotthard2] Copies detector server via TCP (without tftp). Makes a symbolic link with a shorter name (without vx.x.x). Then, detector controller reboots (except Eiger).\n\t[Jungfrau][Moench][Ctb]Also changes respawn server to the link, which is effective after a reboot."
|
|
actions:
|
|
PUT:
|
|
argc: 1
|
|
require_det_id: true
|
|
function: updateDetectorServer
|
|
input: [ 'args[0]' ]
|
|
arg_types: [special::path]
|
|
input_types: [ std::string ]
|
|
output: [ '"successful"' ]
|
|
|
|
updatekernel:
|
|
help: "[kernel_name with full path]\n\t[Jungfrau][Moench][Ctb][Mythen3][Gotthard2] Advanced Command!! You could damage the detector. Please use with caution.\n\tUpdates the kernel image. Then, detector controller reboots with new kernel."
|
|
actions:
|
|
PUT:
|
|
argc: 1
|
|
require_det_id: true
|
|
function: updateKernel
|
|
input: [ 'args[0]' ]
|
|
arg_types: [special::path]
|
|
input_types: [ std::string ]
|
|
output: [ '"successful"' ]
|
|
|
|
update:
|
|
help: "\n\tWithout tftp: [server_name (incl fullpath)] [fname.pof (incl full path)] This does not use tftp.\n\t\t[Jungfrau][Moench][Gotthard][Ctb] Updates the firmware, detector server, deletes old server, creates the symbolic link and then reboots detector controller. \n\t\t[Mythen3][Gotthard2] will require a script to start up the shorter named server link at start up. \n\t\tserver_name is full path name of detector server binary\n\t\tfname is full path of programming file"
|
|
actions:
|
|
PUT:
|
|
argc: 2
|
|
exceptions:
|
|
- condition: 'args[args.size() - 1].find(".pof") == std::string::npos && args[args.size() - 1].find(".rbf") == std::string::npos'
|
|
message: '"Programming file must be a pof/rbf file."'
|
|
require_det_id: true
|
|
function: updateFirmwareAndServer
|
|
input: [ 'args[0]', 'args[1]' ]
|
|
arg_types: [ special::path, special::path ]
|
|
input_types: [ std::string, std::string ]
|
|
output: [ '"successful"' ]
|
|
|
|
reg:
|
|
help: "[address] [32 bit value][(optional)--validate]\n\t[Mythen3][Gotthard2] Reads/writes to a 32 bit register in hex. Advanced Function!\n\tGoes to stop server. Hence, can be called while calling blocking acquire().\n\t\t Use --validate to force validation when writing to it.\n\t[Eiger] +0x100 for only left, +0x200 for only right."
|
|
actions:
|
|
GET:
|
|
argc: 1
|
|
require_det_id: true
|
|
function: readRegister
|
|
input: [ 'args[0]' ]
|
|
input_types: [ uint32_t ]
|
|
cast_input: [ true ]
|
|
output: [ OutStringHex(t) ]
|
|
PUT:
|
|
require_det_id: true
|
|
function: writeRegister
|
|
output: [ '"["', 'args[0]', '", "', 'args[1]', '"]"' ]
|
|
args:
|
|
- argc: 2
|
|
input: [ 'args[0]', 'args[1]', '"0"' ]
|
|
input_types: [ uint32_t, uint32_t, bool ]
|
|
arg_types: [ uint32_t, uint32_t ]
|
|
cast_input: [ true, true, true ]
|
|
- argc: 3
|
|
arg_types: [ uint32_t, uint32_t, special::validate ]
|
|
exceptions:
|
|
- condition: 'args[2] != "--validate"'
|
|
message: '"Could not scan third argument. Did you mean --validate?"'
|
|
input: [ 'args[0]', 'args[1]', '"1"' ]
|
|
input_types: [ uint32_t, uint32_t, bool ]
|
|
cast_input: [ true, true, true ]
|
|
|
|
adcreg:
|
|
help: "[address] [value]\n\t[Jungfrau][Moench][Ctb][Gotthard] Writes to an adc register in hex. Advanced user Function!"
|
|
actions:
|
|
PUT:
|
|
argc: 2
|
|
require_det_id: true
|
|
function: writeAdcRegister
|
|
input: [ 'args[0]', 'args[1]' ]
|
|
input_types: [ uint32_t, uint32_t ]
|
|
cast_input: [ true, true ]
|
|
output: [ ToString(args) ]
|
|
|
|
getbit:
|
|
help: "[reg address in hex] [bit index]\n\tGets bit in address."
|
|
actions:
|
|
GET:
|
|
argc: 2
|
|
exceptions:
|
|
- condition: 'StringTo<int>(args[1]) < 0 || StringTo<int>(args[1]) > 31'
|
|
message: '"Bit number out of range: " + args[1]'
|
|
require_det_id: true
|
|
function: getBit
|
|
input: [ 'args[0]', 'args[1]' ]
|
|
input_types: [ uint32_t, int ]
|
|
cast_input: [ true, true ]
|
|
output: [ OutString(t) ]
|
|
|
|
Setbit:
|
|
template: true
|
|
actions:
|
|
PUT:
|
|
require_det_id: true
|
|
function: setBit
|
|
output: [ '"["', 'args[0]', '", "', 'args[1]', '"]"' ]
|
|
args:
|
|
- argc: 2
|
|
exceptions:
|
|
- condition: 'StringTo<int>(args[1]) < 0 || StringTo<int>(args[1]) > 31'
|
|
message: '"Bit number out of range: " + args[1]'
|
|
input: [ 'args[0]', 'args[1]', '"0"' ]
|
|
input_types: [ uint32_t, int, bool ]
|
|
arg_types: [ uint32_t, int ]
|
|
cast_input: [ true, true, true ]
|
|
- argc: 3
|
|
arg_types: [ uint32_t, int, special::validate ]
|
|
exceptions:
|
|
- condition: 'StringTo<int>(args[1]) < 0 || StringTo<int>(args[1]) > 31'
|
|
message: '"Bit number out of range: " + args[1]'
|
|
- condition: 'args[2] != "--validate"'
|
|
message: '"Could not scan third argument. Did you mean --validate?"'
|
|
input: [ 'args[0]', 'args[1]', '"1"' ]
|
|
input_types: [ uint32_t, int, bool ]
|
|
cast_input: [ true, true, true ]
|
|
|
|
|
|
setbit:
|
|
inherit_actions: Setbit
|
|
help: "[reg address in hex] [bit index]\n\tSets bit in address.\n\tUse --validate to force validation."
|
|
actions:
|
|
PUT:
|
|
function: setBit
|
|
|
|
clearbit:
|
|
inherit_actions: Setbit
|
|
help: "[reg address in hex] [bit index]\n\tClears bit in address.\n\tUse --validate to force validation."
|
|
actions:
|
|
PUT:
|
|
function: clearBit
|
|
|
|
initialchecks:
|
|
help: "[0, 1]\n\t[Mythen3][Gotthard2] Enable or disable intial compatibility and other checks at detector start up. It is enabled by default. Must come before 'hostname' command to take effect. Can be used to reprogram fpga when current firmware is incompatible.\n\tAdvanced User function!"
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
check_det_id: true
|
|
function: getInitialChecks
|
|
output: [ t ]
|
|
PUT:
|
|
argc: 1
|
|
check_det_id: true
|
|
function: setInitialChecks
|
|
input: [ 'args[0]' ]
|
|
input_types: [ bool ]
|
|
cast_input: [ true ]
|
|
output: [ args.front() ]
|
|
|
|
user:
|
|
help: "\n\tUser details from shared memory (hostname, type, PID, User, Date)."
|
|
actions:
|
|
GET:
|
|
argc: 0
|
|
check_det_id: true
|
|
function: getUserDetails
|
|
output: [ t ]
|
|
|
|
|
|
|
|
|
|
|
|
|