Index: fact/tools/PyDimCtrl/fact_dim_servers.py =================================================================== --- fact/tools/PyDimCtrl/fact_dim_servers.py (revision 14788) +++ fact/tools/PyDimCtrl/fact_dim_servers.py (revision 14788) @@ -0,0 +1,2250 @@ +from make_fix_dimservers import FactDimServer +class FTM_CONTROL ( FactDimServer): + def version_number(self): + """ Native Dim service: Version number of Dim in use|DimVer[int]:Version*100+Release (e.g. V19r17 = 1917) +L + """ + return self._get("VERSION_NUMBER") + def disable_reports(self, *args): + """ disable sending rate reports|status[bool]:disable or enable that the FTM sends rate reports (yes/no) +B + """ + self._cmd("DISABLE_REPORTS", *args) + def toggle_pixel(self, *args): + """ DESC in SERVICE_DESC is empty ?! +S:1 + """ + self._cmd("TOGGLE_PIXEL", *args) + def disable_all_patches_except(self, *args): + """ DESC in SERVICE_DESC is empty ?! +S:1 + """ + self._cmd("DISABLE_ALL_PATCHES_EXCEPT", *args) + def set_trigger_multiplicity(self, *args): + """ Setup the Multiplicity condition for physcis triggers|N[int]:Number of requirered coincident triggers from sum-patches (1-40) +S:1 + """ + self._cmd("SET_TRIGGER_MULTIPLICITY", *args) + def state(self): + """ Provides the state of the state machine as quality of service.|Text[string]:A human readable string sent by the last state change. +C + """ + return self._get("STATE") + def set_trigger_interval(self, *args): + """ Sets the trigger interval which is the distance between two consecutive artificial triggers.|interval[ms]:The applied trigger interval in millisecond (min 1ms / 10bit) +I:1 + """ + self._cmd("SET_TRIGGER_INTERVAL", *args) + def enable_ftu(self, *args): + """ Enable or disable FTU|Board[idx]:Index of the board (0-39), -1 for all|Enable[bool]:Whether FTU should be enabled or disabled (yes/no) +I:1;B:1 + """ + self._cmd("ENABLE_FTU", *args) + def service_list(self): + """ Native Dim service: List of services, commands and formats|ServiceList[string]:For details see the Dim manual. +C + """ + return self._get("SERVICE_LIST") + def set_calibration_multiplicity(self, *args): + """ Setup the Multiplicity condition for artificial (calibration) triggers|N[int]:Number of requirered coincident triggers from sum-patches (1-40) +S:1 + """ + self._cmd("SET_CALIBRATION_MULTIPLICITY", *args) + def reset_crate(self, *args): + """ Reset one of the crates 0-3|crate[short]:Crate number to be reseted (0-3) +S:1 + """ + self._cmd("RESET_CRATE", *args) + def reset_configure(self, *args): + """ Reset states during a configuration or in case of configuration error + + """ + self._cmd("RESET_CONFIGURE", *args) + def disable_pixel(self, *args): + """ (-1 or all) +S:1 + """ + self._cmd("DISABLE_PIXEL", *args) + def enable_veto(self, *args): + """ Enable veto line|Enable[bool]:Enable veto (yes/no) +B:1 + """ + self._cmd("ENABLE_VETO", *args) + def enable_pixel(self, *args): + """ (-1 or all) +S:1 + """ + self._cmd("ENABLE_PIXEL", *args) + def set_calibration_window(self, *args): + """ DESC in SERVICE_DESC is empty ?! +S:1 + """ + self._cmd("SET_CALIBRATION_WINDOW", *args) + def enable_ext1(self, *args): + """ Switch on the triggers through the first external line|Enable[bool]:Enable ext1 trigger (yes/no) +B:1 + """ + self._cmd("ENABLE_EXT1", *args) + def set_trigger_window(self, *args): + """ DESC in SERVICE_DESC is empty ?! +S:1 + """ + self._cmd("SET_TRIGGER_WINDOW", *args) + def service_desc(self): + """ Descriptions of services or commands and there arguments|Description[string]:For a detailed explanation of the descriptive string see the class reference of DimDescriptionService. +C + """ + return self._get("SERVICE_DESC") + def state_list(self): + """ Provides a list with descriptions for each service.|StateList[string]:A \n separated list of the form id:name=description +C + """ + return self._get("STATE_LIST") + def set_threshold(self, *args): + """ Set the comparator threshold|Patch[idx]:Index of the patch (0-159), -1 for all|Threshold[counts]:Threshold to be set in binary counts +I:2 + """ + self._cmd("SET_THRESHOLD", *args) + def request_static_data(self, *args): + """ request transmission of static data from FTM to memory + + """ + self._cmd("REQUEST_STATIC_DATA", *args) + def dynamic_data(self): + """ Regular reports sent by FTM|FTMtimeStamp[us]:Time in microseconds, since trigger enabled or disabled|OnTimeCounter[us]:Ontime, i.e. FTM processes triggers (e.g. No FAD busy)|Temperatures[Nan]:not yet defined nor used (wanna be FTM onboard temps)|TriggerPatchCounter[int]:counting since last update (prescaling)|BoardsCounter[int]:FTU board counting after N out of 4 and since last update|RateOverflow[bitpattern]:bits 0-4=patches overflow, 5=board overflow, 1 per board|Prescaling[500ms]:Update rate of the rate counter|CrcError[int]:Number of checksum error in RS485 communication|State[int]:State value of the FTM firmware (cf. FTM doc) +X:1;X:1;F:4;I:160;I:40;S:40;S:40;S:40;S:1 + """ + return self._get("DYNAMIC_DATA") + def set_time_marker_delay(self, *args): + """ |delay[int]:The applied time marker delay is: delay*4ns+8ns +I:1 + """ + self._cmd("SET_TIME_MARKER_DELAY", *args) + def configure(self, *args): + """ DESC in SERVICE_DESC is empty ?! +C + """ + self._cmd("CONFIGURE", *args) + def reconnect(self, *args): + """ (Re)connect ethernet connection to FTM, a new address can be given|[host][string]:new ethernet address in the form +O + """ + self._cmd("RECONNECT", *args) + def enable_clock_conditioner(self, *args): + """ Enable clock conidtioner output in favor of time marker output|Enable[bool]:Enable clock conditioner (yes/no) +B:1 + """ + self._cmd("ENABLE_CLOCK_CONDITIONER", *args) + def take_n_events(self, *args): + """ take n events (distribute n triggers)|number[int]:Number of events to be taken +I + """ + self._cmd("TAKE_N_EVENTS", *args) + def enable_group1_lpint(self, *args): + """ DESC in SERVICE_DESC is empty ?! +B:1 + """ + self._cmd("ENABLE_GROUP1_LPINT", *args) + def exit(self, *args): + """ This is a native Dim command: Exit programremotely. FACT++ programs use the given number as return code.|Rc[int]:Return code, under normal circumstances this should be 0 or 1 (42 will call exit() directly, 0x42 will call abort() directly. +L:1 + """ + self._cmd("EXIT", *args) + def trigger_rates(self): + """ Patch,Board,Camera trigger rates|FTMtimeStamp[us]:Time in microseconds, since trigger enabled or disabled|OnTimeCounter[us]:Effective on-time, ie. FTM triggers (eg. w/o busy)|TriggerCounter[int]:Counter of triggers since enabled or disabled|TriggerRate[Hz]:Trigger rate|BoardRate[Hz]:Trigger rate of individual FTUs|PatchRate[Hz]:Trigger rate of individual patches|ElapsedTime[sec]:Time elapsed since previous report|OnTime[sec]:OnTime elapsed since previous report +X:1;X:1;I:1;F:1;F:40;F:160;F:1;F:1 + """ + return self._get("TRIGGER_RATES") + def passport(self): + """ Info about the FTM and FPGA version|BoardId[int]:BoardId, hexCode|DNA[int]:DNA of the FTM board +X:1;S:1 + """ + return self._get("PASSPORT") + def set_n_out_of_4(self, *args): + """ Set the comparator threshold|Board[idx]:Index of the board (0-39), -1 for all|Threshold[counts]:Threshold to be set in binary counts +I:2 + """ + self._cmd("SET_N_OUT_OF_4", *args) + def set_intensity_lpext(self, *args): + """ DESC in SERVICE_DESC is empty ?! +S:1 + """ + self._cmd("SET_INTENSITY_LPEXT", *args) + def enable_group2_lpext(self, *args): + """ DESC in SERVICE_DESC is empty ?! +B:1 + """ + self._cmd("ENABLE_GROUP2_LPEXT", *args) + def enable_group1_lpext(self, *args): + """ DESC in SERVICE_DESC is empty ?! +B:1 + """ + self._cmd("ENABLE_GROUP1_LPEXT", *args) + def set_clock_register(self, *args): + """ DESC in SERVICE_DESC is empty ?! +X:8 + """ + self._cmd("SET_CLOCK_REGISTER", *args) + def load(self, *args): + """ Loads the static data (FTM configuration) from a file into memory and sends it to the FTM|filename[string]:Filename (can include a path), .bin is automatically added +C + """ + self._cmd("LOAD", *args) + def save(self, *args): + """ Saves the static data (FTM configuration) from memory to a file|filename[string]:Filename (can include a path), .bin is automatically added +C + """ + self._cmd("SAVE", *args) + def toggle_ftu(self, *args): + """ Toggle status of FTU (this is mainly meant to be used in the GUI)|Board[idx]:Index of the board (0-39) +I:1 + """ + self._cmd("TOGGLE_FTU", *args) + def ftu_list(self): + """ Logs the changes of status of the FTUs|FTMtimeStamp[us]:Time in microseconds|ActiveFTU[bitpattern]:Description of enabled FTUs|NumBoards[int]:Total number of enabled FTUs|NumBoardsCrate[int]:Total number of enabled FTUs per crate|DNA[hexCode]:Hex code identifier of FTUs|Addr[bitpattern]:Crate address (hardware) of FTUs|Ping[int]:Number of pings until FTU response +X:1;X:1;S:1;C:4;X:40;C:40;C:40 + """ + return self._get("FTU_LIST") + def client_list(self): + """ Native Dim service: A list of all connected clients +C + """ + return self._get("CLIENT_LIST") + def set_register(self, *args): + """ set register to value|addr[short]:Address of register|val[short]:Value to be set +I:2 + """ + self._cmd("SET_REGISTER", *args) + def enable_ext2(self, *args): + """ Switch on the triggers through the second external line|Enable[bool]:Enable ext2 trigger (yes/no) +B:1 + """ + self._cmd("ENABLE_EXT2", *args) + def enable_group2_lpint(self, *args): + """ DESC in SERVICE_DESC is empty ?! +B:1 + """ + self._cmd("ENABLE_GROUP2_LPINT", *args) + def toggle_led(self, *args): + """ toggle led + + """ + self._cmd("TOGGLE_LED", *args) + def counter(self): + """ Communication statistics to or from FTM control and FTM|NumHeaders[int]:Num. of headers (any header) received by ftm control|NumStaticData[int]:Num. of static data blocks (ftm and ftu settings)|NumDynamicData[int]:Num. of dynamic data blocks (e.g. rates)|NumFtuList[int]:Num. of FTU list (FTU identifiers, answer from ping)|NumErrors[int]:Num. of error messages|NumRegister[int]:Num. of answers from a single register accesess +I:1;I:1;I:1;I:1;I:1;I:1 + """ + return self._get("COUNTER") + def enable_patch(self, *args): + """ DESC in SERVICE_DESC is empty ?! +S:1 + """ + self._cmd("ENABLE_PATCH", *args) + def set_dead_time(self, *args): + """ |dead_time[int]:The applied dead time is: dead_time*4ns+8ns +I:1 + """ + self._cmd("SET_DEAD_TIME", *args) + def enable_trigger(self, *args): + """ Switch on the physics trigger|Enable[bool]:Enable physics trigger (yes/no) +B:1 + """ + self._cmd("ENABLE_TRIGGER", *args) + def set_verbose(self, *args): + """ set verbosity state|verbosity[bool]:disable or enable verbosity for received data (yes/no), except dynamic data +B + """ + self._cmd("SET_VERBOSE", *args) + def message(self): + """ A general logging service providing a quality of service (severity)|Message[string]:The message +C + """ + return self._get("MESSAGE") + def set_trigger_delay(self, *args): + """ |delay[int]:The applied trigger delay is: delay*4ns+8ns +I:1 + """ + self._cmd("SET_TRIGGER_DELAY", *args) + def reset_camera(self, *args): + """ Reset all crates. The commands are sent in the order 0,1,2,3 + + """ + self._cmd("RESET_CAMERA", *args) + def stop_trigger(self, *args): + """ stop a run (stop distributing triggers) + + """ + self._cmd("STOP_TRIGGER", *args) + def set_hex_output(self, *args): + """ enable or disable hex output for received data|hexout[bool]:disable or enable hex output for received data (yes/no) +B + """ + self._cmd("SET_HEX_OUTPUT", *args) + def set_prescaling(self, *args): + """ Sets the FTU readout time intervals|time[0.5s]:The interval is given in units of 0.5s, i.e. 1 means 0.5s, 2 means 1s, ... +I:1 + """ + self._cmd("SET_PRESCALING", *args) + def ping(self, *args): + """ send ping + + """ + self._cmd("PING", *args) + def static_data(self): + """ Configuration of FTM and FTUs|FTMtimeStamp[us]:Time in microseconds, since trigger enabled or disabled|GeneralSettings[bitpattern]:Status of the FTM settings (cf. FTM doc)|LEDStatus[bitpattern]:Not Used|ActiveFTU[bitpattern]:List of enabled FTUs|TriggerInterval[bitpattern]:Period of cal. and ped. events (cf. FTM doc)|TriggerSeq[int]:Sequence of calib. and pedestal events (LPint, LPext, Ped)|LPSettings[bitpattern]:Settings of LP, enabled int, ext, intensity int, ext|PhysTrigMult[int]:N for N out of 40 logic on FTM (Physics)|CalibTrigMult[int]: N for N out of 40 logic on FTM (Calib)|PhysTrigWindow[ns]:Coincidence window for N out of 40 (Physics)|CalibTrigWindow[ns]:Coincidence window for N out of 40 (Calib)|TrigDelay[ns]:Trigger delay applied on FTM|TMDelay[ns]:TM delay applied on FTM|DeadTime[ns]:Dead time applied after each event on the FTM|ClkCond[bitpattern]:Clock conditionner settings on the FTM (DRS sampling freq.)|PixEnabled[bitpattern]:Enabled pixels, pckd in 90 shorts (160*9bits=180bytes)|PatchThresh[DACcounts]:Threshold of the trigger patches|Multiplicity[DACcounts]:N out of 4 logic settings per FTU|Prescaling[500ms]:Update rate of the rate counter +X:1;S:1;S:1;X:1;S:1;S:3;C:4;S:1;S:1;S:1;S:1;S:1;S:1;I:1;I:8;S:90;S:160;S:40;S:40 + """ + return self._get("STATIC_DATA") + def error(self): + """ DESC in SERVICE_DESC is empty ?! +X:1;S:1;S:28 + """ + return self._get("ERROR") + def start_trigger(self, *args): + """ start a run (start distributing triggers) + + """ + self._cmd("START_TRIGGER", *args) + def get_register(self, *args): + """ read register from address addr|addr[short]:Address of register +I + """ + self._cmd("GET_REGISTER", *args) + def disconnect(self, *args): + """ disconnect from ethernet + + """ + self._cmd("DISCONNECT", *args) + def disable_all_pixels_except(self, *args): + """ DESC in SERVICE_DESC is empty ?! +S:1 + """ + self._cmd("DISABLE_ALL_PIXELS_EXCEPT", *args) + def set_trigger_sequence(self, *args): + """ Setup the sequence of artificial triggers produced by the FTM|Ped[short]:number of pedestal triggers in a row|LPext[short]:number of triggers of the external light pulser|LPint[short]:number of triggers of the internal light pulser +S:3 + """ + self._cmd("SET_TRIGGER_SEQUENCE", *args) + def set_dynamic_output(self, *args): + """ enable or disable output for received dynamic data (data is still broadcasted via Dim)|dynout[bool]:disable or enable output for dynamic data (yes/no) +B + """ + self._cmd("SET_DYNAMIC_OUTPUT", *args) + def disable_patch(self, *args): + """ DESC in SERVICE_DESC is empty ?! +S:1 + """ + self._cmd("DISABLE_PATCH", *args) + def set_clock_frequency(self, *args): + """ DESC in SERVICE_DESC is empty ?! +S:1 + """ + self._cmd("SET_CLOCK_FREQUENCY", *args) + def request_dynamic_data(self, *args): + """ request transmission of dynamic data block + + """ + self._cmd("REQUEST_DYNAMIC_DATA", *args) + def set_intensity_lpint(self, *args): + """ DESC in SERVICE_DESC is empty ?! +S:1 + """ + self._cmd("SET_INTENSITY_LPINT", *args) +class RATE_SCAN ( FactDimServer): + def process_data(self): + """ Rate scan process data|min[DAC]:Value at which scan was started|max[DAC]:Value at which scan will end|step[DAC]:Step size for scan +I:1;I:1;I:1 + """ + return self._get("PROCESS_DATA") + def state(self): + """ Provides the state of the state machine as quality of service.|Text[string]:A human readable string sent by the last state change. +C + """ + return self._get("STATE") + def service_desc(self): + """ Descriptions of services or commands and there arguments|Description[string]:For a detailed explanation of the descriptive string see the class reference of DimDescriptionService. +C + """ + return self._get("SERVICE_DESC") + def service_list(self): + """ Native Dim service: List of services, commands and formats|ServiceList[string]:For details see the Dim manual. +C + """ + return self._get("SERVICE_LIST") + def start_threshold_scan(self, *args): + """ Start rate scan for the threshold in the defined range|min[int]:Start value in DAC counts|max[int]:Limiting value in DAC counts|step[int]:Single step in DAC counts +I:3 + """ + self._cmd("START_THRESHOLD_SCAN", *args) + def print_cmd(self, *args): + """ DESC in SERVICE_DESC is empty ?! + + """ + self._cmd("PRINT_CMD", *args) + def client_list(self): + """ Native Dim service: A list of all connected clients +C + """ + return self._get("CLIENT_LIST") + def set_reference_patch(self, *args): + """ Use the given patch trigger-rate as reference for the reolution|patch[idx]:Index of the patch (360*crate+36*board+patch) +I:1 + """ + self._cmd("SET_REFERENCE_PATCH", *args) + def exit(self, *args): + """ This is a native Dim command: Exit programremotely. FACT++ programs use the given number as return code.|Rc[int]:Return code, under normal circumstances this should be 0 or 1 (42 will call exit() directly, 0x42 will call abort() directly. +L:1 + """ + self._cmd("EXIT", *args) + def change_step_size(self, *args): + """ Change the step size during a ratescan in progress|step[int]:Single step in DAC counts +I:1 + """ + self._cmd("CHANGE_STEP_SIZE", *args) + def data(self): + """ |Id[s]:Start time used to identify measurement (UnixTime)|Threshold[dac]:Threshold in DAC counts|ElapsedTime[s]:Real elapsed time|RelOnTime[ratio]:Relative on time|TriggerRate[Hz]:Camera trigger rate|BoardRate[Hz]:Board trigger rates|PatchRate[Hz]:Patch trigger rates +X:1;I:1;F:1;F:1;F:1;F:40;F:160 + """ + return self._get("DATA") + def stop(self, *args): + """ Stop a ratescan in progress + + """ + self._cmd("STOP", *args) + def message(self): + """ A general logging service providing a quality of service (severity)|Message[string]:The message +C + """ + return self._get("MESSAGE") + def start_n_out_of_4_scan(self, *args): + """ Start rate scan for N-out-of-4 in the defined range|min[int]:Start value in DAC counts|max[int]:Limiting value in DAC counts|step[int]:Single step in DAC counts +I:3 + """ + self._cmd("START_N_OUT_OF_4_SCAN", *args) + def change_maximum(self, *args): + """ Change the maximum limit during a ratescan in progress|max[int]:Limiting value in DAC counts +I:1 + """ + self._cmd("CHANGE_MAXIMUM", *args) + def state_list(self): + """ Provides a list with descriptions for each service.|StateList[string]:A \n separated list of the form id:name=description +C + """ + return self._get("STATE_LIST") + def version_number(self): + """ Native Dim service: Version number of Dim in use|DimVer[int]:Version*100+Release (e.g. V19r17 = 1917) +L + """ + return self._get("VERSION_NUMBER") + def set_reference_board(self, *args): + """ Use the given board trigger-rate as reference for the reolution|board[idx]:Index of the board (4*crate+board) +I:1 + """ + self._cmd("SET_REFERENCE_BOARD", *args) + def set_reference_camera(self, *args): + """ Use the camera trigger rate as reference for the reolution + + """ + self._cmd("SET_REFERENCE_CAMERA", *args) +class RATE_CONTROL ( FactDimServer): + def state(self): + """ Provides the state of the state machine as quality of service.|Text[string]:A human readable string sent by the last state change. +C + """ + return self._get("STATE") + def client_list(self): + """ Native Dim service: A list of all connected clients +C + """ + return self._get("CLIENT_LIST") + def stop(self, *args): + """ Stop a calibration or ratescan in progress + + """ + self._cmd("STOP", *args) + def service_list(self): + """ Native Dim service: List of services, commands and formats|ServiceList[string]:For details see the Dim manual. +C + """ + return self._get("SERVICE_LIST") + def state_list(self): + """ Provides a list with descriptions for each service.|StateList[string]:A \n separated list of the form id:name=description +C + """ + return self._get("STATE_LIST") + def message(self): + """ A general logging service providing a quality of service (severity)|Message[string]:The message +C + """ + return self._get("MESSAGE") + def print_cmd(self, *args): + """ Print current status + + """ + self._cmd("PRINT_CMD", *args) + def calibrate(self, *args): + """ Start a search for a reasonable minimum global threshold + + """ + self._cmd("CALIBRATE", *args) + def service_desc(self): + """ Descriptions of services or commands and there arguments|Description[string]:For a detailed explanation of the descriptive string see the class reference of DimDescriptionService. +C + """ + return self._get("SERVICE_DESC") + def set_verbose(self, *args): + """ set verbosity state|verbosity[bool]:disable or enable verbosity for received data (yes/no), except dynamic data +B + """ + self._cmd("SET_VERBOSE", *args) + def set_target_rate(self, *args): + """ Set a target trigger rate for the calibration +F:1 + """ + self._cmd("SET_TARGET_RATE", *args) + def exit(self, *args): + """ This is a native Dim command: Exit programremotely. FACT++ programs use the given number as return code.|Rc[int]:Return code, under normal circumstances this should be 0 or 1 (42 will call exit() directly, 0x42 will call abort() directly. +L:1 + """ + self._cmd("EXIT", *args) + def threshold(self): + """ Resulting threshold after calibration|threshold[dac]:Resulting threshold from calibration +S:1 + """ + return self._get("THRESHOLD") + def set_min_threshold(self, *args): + """ Set a minimum threshold at which th rate control starts calibrating +I:1 + """ + self._cmd("SET_MIN_THRESHOLD", *args) + def version_number(self): + """ Native Dim service: Version number of Dim in use|DimVer[int]:Version*100+Release (e.g. V19r17 = 1917) +L + """ + return self._get("VERSION_NUMBER") +class FEEDBACK ( FactDimServer): + def reference(self): + """ Amplitude reference value(s)Vref[mV]:Amplitude reference +F:416 + """ + return self._get("REFERENCE") + def enable_output(self, *args): + """ Enable sending of correction values caluclated by the control loop to the biasctrl +B:1 + """ + self._cmd("ENABLE_OUTPUT", *args) + def version_number(self): + """ Native Dim service: Version number of Dim in use|DimVer[int]:Version*100+Release (e.g. V19r17 = 1917) +L + """ + return self._get("VERSION_NUMBER") + def print_calibration(self, *args): + """ DESC in SERVICE_DESC is empty ?! + + """ + self._cmd("PRINT_CALIBRATION", *args) + def exit(self, *args): + """ This is a native Dim command: Exit programremotely. FACT++ programs use the given number as return code.|Rc[int]:Return code, under normal circumstances this should be 0 or 1 (42 will call exit() directly, 0x42 will call abort() directly. +L:1 + """ + self._cmd("EXIT", *args) + def state(self): + """ Provides the state of the state machine as quality of service.|Text[string]:A human readable string sent by the last state change. +C + """ + return self._get("STATE") + def stop(self, *args): + """ Stop any control loop + + """ + self._cmd("STOP", *args) + def start_temp_control(self, *args): + """ Start the temperature control loop|offset[V]:Offset from the nominal temperature corrected value in Volts +F:1 + """ + self._cmd("START_TEMP_CONTROL", *args) + def set_kp(self, *args): + """ Set proportional constant Kp +D:1 + """ + self._cmd("SET_KP", *args) + def store_reference(self, *args): + """ Store the last (averaged) value as new reference (for debug purpose only) + + """ + self._cmd("STORE_REFERENCE", *args) + def service_desc(self): + """ Descriptions of services or commands and there arguments|Description[string]:For a detailed explanation of the descriptive string see the class reference of DimDescriptionService. +C + """ + return self._get("SERVICE_DESC") + def print_cmd(self, *args): + """ DESC in SERVICE_DESC is empty ?! + + """ + self._cmd("PRINT_CMD", *args) + def set_t(self, *args): + """ Set time-constant. (-1 to use the cycle time, i.e. the time for the last average cycle, instead) +D:1 + """ + self._cmd("SET_T", *args) + def start_feedback_control(self, *args): + """ Start the feedback control loop|Num[short]:Number of events 'medianed' to calculate the correction value +S:1 + """ + self._cmd("START_FEEDBACK_CONTROL", *args) + def set_current_request_interval(self, *args): + """ |interval[ms]:Interval between two current requests in modes which need that. + + """ + self._cmd("SET_CURRENT_REQUEST_INTERVAL", *args) + def set_reference(self, *args): + """ Set a new global reference value (for debug purpose only) +F:1 + """ + self._cmd("SET_REFERENCE", *args) + def start_global_feedback(self, *args): + """ Start the global feedback control loopNum[short]:Number of events averaged to calculate the correction value +S:1 + """ + self._cmd("START_GLOBAL_FEEDBACK", *args) + def deviation(self): + """ Control loop information|DeltaAmpl[mV]:Amplitude offset measures|DeltaBias[mV]:Correction value calculated|DeltaTemp[mV]:Correction calculated from temperature|DeltaUser[mV]:Additional offset specified by user +F:416;F:416;F:1;F:1 + """ + return self._get("DEVIATION") + def client_list(self): + """ Native Dim service: A list of all connected clients +C + """ + return self._get("CLIENT_LIST") + def message(self): + """ A general logging service providing a quality of service (severity)|Message[string]:The message +C + """ + return self._get("MESSAGE") + def calibration(self): + """ Current offsets|Avg[uA]:Average offset|Rms[uA]:Rms of offset|R[Ohm]:Measured calibration resistor +F:416;F:416;F:416 + """ + return self._get("CALIBRATION") + def set_kd(self, *args): + """ Set derivative constant Kd +D:1 + """ + self._cmd("SET_KD", *args) + def set_ki(self, *args): + """ Set integral constant Ki +D:1 + """ + self._cmd("SET_KI", *args) + def start_current_control(self, *args): + """ Start the current/temperature control loop|offset[V]:Offset from the nominal current/temperature corrected value in Volts +F:1 + """ + self._cmd("START_CURRENT_CONTROL", *args) + def calibrate_currents(self, *args): + """ DESC in SERVICE_DESC is empty ?! + + """ + self._cmd("CALIBRATE_CURRENTS", *args) + def state_list(self): + """ Provides a list with descriptions for each service.|StateList[string]:A \n separated list of the form id:name=description +C + """ + return self._get("STATE_LIST") + def service_list(self): + """ Native Dim service: List of services, commands and formats|ServiceList[string]:For details see the Dim manual. +C + """ + return self._get("SERVICE_LIST") +class LID_CONTROL ( FactDimServer): + def data(self): + """ |status[bool]:Lid1/2 open or closed|I[A]:Lid1/2 current|P[dac]:Lid1/2 hall sensor position in averaged dac counts +S:2;F:2;F:2 + """ + return self._get("DATA") + def close(self, *args): + """ Close the lids + + """ + self._cmd("CLOSE", *args) + def post(self, *args): + """ set verbosity state|verbosity[bool]:disable or enable verbosity for received data (yes/no), except dynamic data +C + """ + self._cmd("POST", *args) + def exit(self, *args): + """ This is a native Dim command: Exit programremotely. FACT++ programs use the given number as return code.|Rc[int]:Return code, under normal circumstances this should be 0 or 1 (42 will call exit() directly, 0x42 will call abort() directly. +L:1 + """ + self._cmd("EXIT", *args) + def service_desc(self): + """ Descriptions of services or commands and there arguments|Description[string]:For a detailed explanation of the descriptive string see the class reference of DimDescriptionService. +C + """ + return self._get("SERVICE_DESC") + def version_number(self): + """ Native Dim service: Version number of Dim in use|DimVer[int]:Version*100+Release (e.g. V19r17 = 1917) +L + """ + return self._get("VERSION_NUMBER") + def state_list(self): + """ Provides a list with descriptions for each service.|StateList[string]:A \n separated list of the form id:name=description +C + """ + return self._get("STATE_LIST") + def open(self, *args): + """ Open the lids + + """ + self._cmd("OPEN", *args) + def service_list(self): + """ Native Dim service: List of services, commands and formats|ServiceList[string]:For details see the Dim manual. +C + """ + return self._get("SERVICE_LIST") + def message(self): + """ A general logging service providing a quality of service (severity)|Message[string]:The message +C + """ + return self._get("MESSAGE") + def client_list(self): + """ Native Dim service: A list of all connected clients +C + """ + return self._get("CLIENT_LIST") + def set_verbose(self, *args): + """ set verbosity state|verbosity[bool]:disable or enable verbosity for received data (yes/no), except dynamic data +B + """ + self._cmd("SET_VERBOSE", *args) + def state(self): + """ Provides the state of the state machine as quality of service.|Text[string]:A human readable string sent by the last state change. +C + """ + return self._get("STATE") +class FSC_CONTROL ( FactDimServer): + def state_list(self): + """ Provides a list with descriptions for each service.|StateList[string]:A \n separated list of the form id:name=description +C + """ + return self._get("STATE_LIST") + def state(self): + """ Provides the state of the state machine as quality of service.|Text[string]:A human readable string sent by the last state change. +C + """ + return self._get("STATE") + def exit(self, *args): + """ This is a native Dim command: Exit programremotely. FACT++ programs use the given number as return code.|Rc[int]:Return code, under normal circumstances this should be 0 or 1 (42 will call exit() directly, 0x42 will call abort() directly. +L:1 + """ + self._cmd("EXIT", *args) + def voltage(self): + """ |t[s]:FSC uptime|FAD_Ud[V]:FAD digital (crate 0-3)|FAD_Up[V]:FAD positive (crate 0-3)|FAD_Un[V]:FAD negative (crate 0-3)|FPA_Ud[V]:FPA digital (crate 0-3)|FPA_Up[V]:FPA positive (crate 0-3)|FPA_Un[V]:FPA negative (crate 0-3)|ETH_U[V]:Ethernet switch (pos/neg)|FTM_U[V]:FTM - trigger master (pos/neg)|FFC_U[V]:FFC|FLP_U[V]:FLP - light pulser +F:1;F:4;F:4;F:4;F:4;F:4;F:4;F:2;F:2;F:1;F:1 + """ + return self._get("VOLTAGE") + def current(self): + """ |t[s]:FSC uptime|FAD_Id[A]:FAD digital (crate 0-3)|FAD_Ip[A]:FAD positive (crate 0-3)|FAD_In[A]:FAD negative (crate 0-3)|FPA_Id[A]:FPA digital (crate 0-3)|FPA_Ip[A]:FPA positive (crate 0-3)|FPA_In[A]:FPA negative (crate 0-3)|ETH_I[A]:Ethernet switch (pos/neg)|FTM_I[A]:FTM - trigger master (pos/neg)|FFC_I[A]:FFC|FLP_I[A]:FLP - light pulser +F:1;F:4;F:4;F:4;F:4;F:4;F:4;F:2;F:2;F:1;F:1 + """ + return self._get("CURRENT") + def client_list(self): + """ Native Dim service: A list of all connected clients +C + """ + return self._get("CLIENT_LIST") + def service_list(self): + """ Native Dim service: List of services, commands and formats|ServiceList[string]:For details see the Dim manual. +C + """ + return self._get("SERVICE_LIST") + def service_desc(self): + """ Descriptions of services or commands and there arguments|Description[string]:For a detailed explanation of the descriptive string see the class reference of DimDescriptionService. +C + """ + return self._get("SERVICE_DESC") + def version_number(self): + """ Native Dim service: Version number of Dim in use|DimVer[int]:Version*100+Release (e.g. V19r17 = 1917) +L + """ + return self._get("VERSION_NUMBER") + def disconnect(self, *args): + """ disconnect from ethernet + + """ + self._cmd("DISCONNECT", *args) + def dump_stream(self, *args): + """ DESC in SERVICE_DESC is empty ?! +B:1 + """ + self._cmd("DUMP_STREAM", *args) + def humidity(self): + """ |t[s]:FSC uptime|H[%]:Humidity sensors readout +F:1;F:4 + """ + return self._get("HUMIDITY") + def temperature(self): + """ |t[s]:FSC uptime|T_sens[deg C]:Sensor compartment temperatures|T_crate[deg C]:Temperatures crate 0 (back/front), 1 (b/f), 2 (b/f), 3 (b/f)|T_ps[deg C]:Temp power supplies crate 0 (back/front), 1, 2, 3|T_aux[deg C]:Auxiliary power supply temperatures FTM (top/bottom), FSC (t/b)|T_back[deg C]:FTM backpanel temperatures FTM (top/bottom), FSC (top/bottom)|T_eth[deg C]:Ethernet switches temperatures top (front/back), bottom (f/b) +F:1;F:31;F:8;F:8;F:4;F:4;F:4 + """ + return self._get("TEMPERATURE") + def set_verbose(self, *args): + """ set verbosity state|verbosity[bool]:disable or enable verbosity for received data (yes/no), except dynamic data +B:1 + """ + self._cmd("SET_VERBOSE", *args) + def reconnect(self, *args): + """ (Re)connect ethernet connection to FTM, a new address can be given|[host][string]:new ethernet address in the form +O + """ + self._cmd("RECONNECT", *args) + def message(self): + """ A general logging service providing a quality of service (severity)|Message[string]:The message +C + """ + return self._get("MESSAGE") +class PWR_CONTROL ( FactDimServer): + def set_verbose(self, *args): + """ Set verbosity state|verbosity[bool]:disable or enable verbosity for interpreted data (yes/no) +B:1 + """ + self._cmd("SET_VERBOSE", *args) + def camera_power(self, *args): + """ Switch camera power|power[bool]:Switch camera power 'on' or 'off' +B:1 + """ + self._cmd("CAMERA_POWER", *args) + def set_debug_rx(self, *args): + """ Set debux-rx state|debug[bool]:dump received text and parsed text to console (yes/no) +B:1 + """ + self._cmd("SET_DEBUG_RX", *args) + def version_number(self): + """ Native Dim service: Version number of Dim in use|DimVer[int]:Version*100+Release (e.g. V19r17 = 1917) +L + """ + return self._get("VERSION_NUMBER") + def service_desc(self): + """ Descriptions of services or commands and there arguments|Description[string]:For a detailed explanation of the descriptive string see the class reference of DimDescriptionService. +C + """ + return self._get("SERVICE_DESC") + def exit(self, *args): + """ This is a native Dim command: Exit programremotely. FACT++ programs use the given number as return code.|Rc[int]:Return code, under normal circumstances this should be 0 or 1 (42 will call exit() directly, 0x42 will call abort() directly. +L:1 + """ + self._cmd("EXIT", *args) + def toggle_drive(self, *args): + """ Toggle drive power + + """ + self._cmd("TOGGLE_DRIVE", *args) + def state(self): + """ Provides the state of the state machine as quality of service.|Text[string]:A human readable string sent by the last state change. +C + """ + return self._get("STATE") + def client_list(self): + """ Native Dim service: A list of all connected clients +C + """ + return self._get("CLIENT_LIST") + def data(self): + """ |water_lvl[bool]:Water level ok|water_flow[bool]:Water flowing|pwr_24V[bool]:24V power enabled|pwr_pump[bool]:Pump power enabled|pwr_bias[bool]:Bias power enabled|pwr_drive[bool]:Drive power enabled (command value)|main_drive[bool]:Drive manual main switch on|feedback_drive[bool]:Drive power on (feedback value) +C:1;C:1;C:1;C:1;C:1;C:1;C:1;C:1 + """ + return self._get("DATA") + def service_list(self): + """ Native Dim service: List of services, commands and formats|ServiceList[string]:For details see the Dim manual. +C + """ + return self._get("SERVICE_LIST") + def post(self, *args): + """ set verbosity state|verbosity[bool]:disable or enable verbosity for received data (yes/no), except dynamic data +C + """ + self._cmd("POST", *args) + def message(self): + """ A general logging service providing a quality of service (severity)|Message[string]:The message +C + """ + return self._get("MESSAGE") + def state_list(self): + """ Provides a list with descriptions for each service.|StateList[string]:A \n separated list of the form id:name=description +C + """ + return self._get("STATE_LIST") +class DATA_LOGGER ( FactDimServer): + def filename_run(self): + """ Path and base name used for the run files.|Type[int]:type of open files (1=log, 2=rep, 4=fits)|Name[string]:path and base file name +I:1;C + """ + return self._get("FILENAME_RUN") + def stop(self, *args): + """ Stop all data logging, close all files. + + """ + self._cmd("STOP", *args) + def message(self): + """ A general logging service providing a quality of service (severity)|Message[string]:The message +C + """ + return self._get("MESSAGE") + def enable_numsubs_service(self, *args): + """ Switch the service which distributes information about the number of subscriptions and open files on or off.|Enable[bool]:Enable of disable NUM_SUBS service (yes/no). +B:1 + """ + self._cmd("ENABLE_NUMSUBS_SERVICE", *args) + def enable_filename_services(self, *args): + """ Switch service which distributes information about the open files on or off.|Enable[bool]:Enable of disable filename services (yes/no). +B:1 + """ + self._cmd("ENABLE_FILENAME_SERVICES", *args) + def exit(self, *args): + """ This is a native Dim command: Exit programremotely. FACT++ programs use the given number as return code.|Rc[int]:Return code, under normal circumstances this should be 0 or 1 (42 will call exit() directly, 0x42 will call abort() directly. +L:1 + """ + self._cmd("EXIT", *args) + def set_run_timeout(self, *args): + """ Set the timeout delay for old run numbers.|timeout[min]:Time out in minutes after which files for expired runs are closed. +L:1 + """ + self._cmd("SET_RUN_TIMEOUT", *args) + def num_subs(self): + """ Num. open files + num. subscribed services|NSubAndOpenFiles[int]:Num. of subs and open files +I:2 + """ + return self._get("NUM_SUBS") + def service_desc(self): + """ Descriptions of services or commands and there arguments|Description[string]:For a detailed explanation of the descriptive string see the class reference of DimDescriptionService. +C + """ + return self._get("SERVICE_DESC") + def set_statistics_update_interval(self, *args): + """ Interval in which the data-logger statistics service (STATS) is updated.|Interval[ms]:Value in milliseconds (<=0: no update). +S:1 + """ + self._cmd("SET_STATISTICS_UPDATE_INTERVAL", *args) + def version_number(self): + """ Native Dim service: Version number of Dim in use|DimVer[int]:Version*100+Release (e.g. V19r17 = 1917) +L + """ + return self._get("VERSION_NUMBER") + def client_list(self): + """ Native Dim service: A list of all connected clients +C + """ + return self._get("CLIENT_LIST") + def set_debug_mode(self, *args): + """ Switch debug mode on or off. Debug mode prints information about every service written to a file.|Enable[bool]:Enable of disable debug mode (yes/no). +B:1 + """ + self._cmd("SET_DEBUG_MODE", *args) + def print_info(self, *args): + """ Print information about the internal status of the data logger. + + """ + self._cmd("PRINT_INFO", *args) + def start(self, *args): + """ Start the nightly logging. Nightly file location must be specified already + + """ + self._cmd("START", *args) + def stop_run_logging(self, *args): + """ Go from the wait for run to nightly open state. + + """ + self._cmd("STOP_RUN_LOGGING", *args) + def service_list(self): + """ Native Dim service: List of services, commands and formats|ServiceList[string]:For details see the Dim manual. +C + """ + return self._get("SERVICE_LIST") + def stats(self): + """ Statistics about size written +X:4 + """ + return self._get("STATS") + def reset(self, *args): + """ Transition to exit error states. Closes the any open file. + + """ + self._cmd("RESET", *args) + def start_run_logging(self, *args): + """ Go to waiting for run number state. In this state with any received run-number a new file is opened. + + """ + self._cmd("START_RUN_LOGGING", *args) + def state_list(self): + """ Provides a list with descriptions for each service.|StateList[string]:A \n separated list of the form id:name=description +C + """ + return self._get("STATE_LIST") + def state(self): + """ Provides the state of the state machine as quality of service.|Text[string]:A human readable string sent by the last state change. +C + """ + return self._get("STATE") + def filename_nightly(self): + """ Path and base name used for the nightly files.|Type[int]:type of open files (1=log, 2=rep, 4=fits)|Name[string]:path and base file name +I:1;C + """ + return self._get("FILENAME_NIGHTLY") +class TNG_WEATHER ( FactDimServer): + def set_verbose(self, *args): + """ set verbosity state|verbosity[bool]:disable or enable verbosity for received data (yes/no), except dynamic data +B + """ + self._cmd("SET_VERBOSE", *args) + def state(self): + """ Provides the state of the state machine as quality of service.|Text[string]:A human readable string sent by the last state change. +C + """ + return self._get("STATE") + def state_list(self): + """ Provides a list with descriptions for each service.|StateList[string]:A \n separated list of the form id:name=description +C + """ + return self._get("STATE_LIST") + def version_number(self): + """ Native Dim service: Version number of Dim in use|DimVer[int]:Version*100+Release (e.g. V19r17 = 1917) +L + """ + return self._get("VERSION_NUMBER") + def dust(self): + """ |Dust[ug/m^3]:Dust (total) +F:1 + """ + return self._get("DUST") + def service_desc(self): + """ Descriptions of services or commands and there arguments|Description[string]:For a detailed explanation of the descriptive string see the class reference of DimDescriptionService. +C + """ + return self._get("SERVICE_DESC") + def client_list(self): + """ Native Dim service: A list of all connected clients +C + """ + return self._get("CLIENT_LIST") + def message(self): + """ A general logging service providing a quality of service (severity)|Message[string]:The message +C + """ + return self._get("MESSAGE") + def data(self): + """ |T_10M[deg C]:Temperature 10m above ground|T_5M[deg C]:Temperature 5m above ground|T_2M[deg C]:Temperature 2m above ground|T_0[deg C]:Temperature at ground|T_dew[deg C]:Dew point|H[%]:Humidity|P[mbar]:Air pressure|v[km/h]:Wind speed|d[deg]:Wind direction (N-E)|DeltaM1|Dust[ug/m^3]:Dust (total)|Seeing[W/m^2]:Seeing +F:1;F:1;F:1;F:1;F:1;F:1;F:1;F:1;F:1;F:1;F:1;F:1 + """ + return self._get("DATA") + def service_list(self): + """ Native Dim service: List of services, commands and formats|ServiceList[string]:For details see the Dim manual. +C + """ + return self._get("SERVICE_LIST") + def exit(self, *args): + """ This is a native Dim command: Exit programremotely. FACT++ programs use the given number as return code.|Rc[int]:Return code, under normal circumstances this should be 0 or 1 (42 will call exit() directly, 0x42 will call abort() directly. +L:1 + """ + self._cmd("EXIT", *args) +class AGILENT_CONTROL ( FactDimServer): + def service_list(self): + """ Native Dim service: List of services, commands and formats|ServiceList[string]:For details see the Dim manual. +C + """ + return self._get("SERVICE_LIST") + def set_verbose(self, *args): + """ set verbosity state|verbosity[bool]:disable or enable verbosity for received data (yes/no) +B:1 + """ + self._cmd("SET_VERBOSE", *args) + def set_power(self, *args): + """ Enable or disable power output|output[bool]:set power output to 'on' or 'off' +B:1 + """ + self._cmd("SET_POWER", *args) + def service_desc(self): + """ Descriptions of services or commands and there arguments|Description[string]:For a detailed explanation of the descriptive string see the class reference of DimDescriptionService. +C + """ + return self._get("SERVICE_DESC") + def power_cycle(self, *args): + """ Power cycle the power output|delay[short]:Defines the delay between switching off and on. +S:1 + """ + self._cmd("POWER_CYCLE", *args) + def version_number(self): + """ Native Dim service: Version number of Dim in use|DimVer[int]:Version*100+Release (e.g. V19r17 = 1917) +L + """ + return self._get("VERSION_NUMBER") + def reconnect(self, *args): + """ (Re)connect ethernet connection to Agilent, a new address can be given|[host][string]:new ethernet address in the form +O + """ + self._cmd("RECONNECT", *args) + def set_debug_rx(self, *args): + """ set debug state|debug[bool]:disable or enable verbosity for received raw data (yes/no) +B:1 + """ + self._cmd("SET_DEBUG_RX", *args) + def message(self): + """ A general logging service providing a quality of service (severity)|Message[string]:The message +C + """ + return self._get("MESSAGE") + def state(self): + """ Provides the state of the state machine as quality of service.|Text[string]:A human readable string sent by the last state change. +C + """ + return self._get("STATE") + def client_list(self): + """ Native Dim service: A list of all connected clients +C + """ + return self._get("CLIENT_LIST") + def disconnect(self, *args): + """ disconnect from ethernet + + """ + self._cmd("DISCONNECT", *args) + def data(self): + """ |U_nom[V]: Nominal output voltage|U_mes[V]: Measured output voltage|I_mes[A]: Measured current|I_max[A]: Current limit +F:1;F:1;F:1;F:1 + """ + return self._get("DATA") + def state_list(self): + """ Provides a list with descriptions for each service.|StateList[string]:A \n separated list of the form id:name=description +C + """ + return self._get("STATE_LIST") + def exit(self, *args): + """ This is a native Dim command: Exit programremotely. FACT++ programs use the given number as return code.|Rc[int]:Return code, under normal circumstances this should be 0 or 1 (42 will call exit() directly, 0x42 will call abort() directly. +L:1 + """ + self._cmd("EXIT", *args) +class FAD_CONTROL ( FactDimServer): + def version_number(self): + """ Native Dim service: Version number of Dim in use|DimVer[int]:Version*100+Release (e.g. V19r17 = 1917) +L + """ + return self._get("VERSION_NUMBER") + def state_list(self): + """ Provides a list with descriptions for each service.|StateList[string]:A \n separated list of the form id:name=description +C + """ + return self._get("STATE_LIST") + def enable_continous_trigger(self, *args): + """ Enable continous (internal) trigger. +B:1 + """ + self._cmd("ENABLE_CONTINOUS_TRIGGER", *args) + def event_data(self): + """ DESC in SERVICE_DESC is empty ?! +F:1440;F:1440;F:1440;F:1440 + """ + return self._get("EVENT_DATA") + def print_event(self, *args): + """ Print (last) event|board[short]:slot from which the event should be printed (-1 for all) +S:1 + """ + self._cmd("PRINT_EVENT", *args) + def block_transmission(self, *args): + """ Blocks the transmission of commands to the given slot. Use with care! For debugging pupose only!|slot[short]:Slot to which the command transmission should be blocked (0-39)|enable[bool]:Whether the command transmission should be blockes (yes) or allowed (no) +S:1;B:1 + """ + self._cmd("BLOCK_TRANSMISSION", *args) + def set_debug_tx(self, *args): + """ Enable or disable the output of messages in case of successfull data transmission to the boards.|debug[bool]:disable or enable debug output for transmitted data (yes/no) +B:1 + """ + self._cmd("SET_DEBUG_TX", *args) + def dac(self): + """ DAC settings of each FAD board|DAC[int]:DAC counts, sequentially DAC 0 board 0, 0/1, 0/2... (plus min max) +S:336 + """ + return self._get("DAC") + def status(self): + """ Status of FAD boards|status[bitpattern]:Status of each FAD board. Maybe buggy +S:42 + """ + return self._get("STATUS") + def disconnect(self, *args): + """ Disconnect a connected slot. +S:1 + """ + self._cmd("DISCONNECT", *args) + def set_max_memory(self, *args): + """ Set maximum memory buffer size allowed to be consumed by the EventBuilder to buffer events.|memory[short]:Buffer size in Mega-bytes. +S:1 + """ + self._cmd("SET_MAX_MEMORY", *args) + def firmware_version(self): + """ Firmware version number of fad boards|firmware[float]:Version number of firmware, for each board. 40=min, 41=max +F:42 + """ + return self._get("FIRMWARE_VERSION") + def load_drs_calibration(self, *args): + """ Load a DRS calibration file|absolute path +C + """ + self._cmd("LOAD_DRS_CALIBRATION", *args) + def add_address(self, *args): + """ Add the address of a DRS4 board to the first free slot|IP[string]:address in the format +C + """ + self._cmd("ADD_ADDRESS", *args) + def drs_runs(self): + """ DESC in SERVICE_DESC is empty ?! +I:1;I:3 + """ + return self._get("DRS_RUNS") + def enable_trigger_line(self, *args): + """ Incoming triggers can be accepted/will not be accepted +B:1 + """ + self._cmd("ENABLE_TRIGGER_LINE", *args) + def enable_dwrite(self, *args): + """ Set Dwrite (possibly high / always low) +B:1 + """ + self._cmd("ENABLE_DWRITE", *args) + def feedback_data(self): + """ DESC in SERVICE_DESC is empty ?! +F:1440 + """ + return self._get("FEEDBACK_DATA") + def set_file_format(self, *args): + """ DESC in SERVICE_DESC is empty ?! +S:1 + """ + self._cmd("SET_FILE_FORMAT", *args) + def reference_clock(self): + """ Reference clock of FAD boards|refClocks[t]:ref clocks of FAD boards. 40=min, 41=max +I:42 + """ + return self._get("REFERENCE_CLOCK") + def phase_shift(self, *args): + """ Adjust ADC phase (in 'steps')|phase[short] +S:1 + """ + self._cmd("PHASE_SHIFT", *args) + def enable_busy_off(self, *args): + """ Set BUSY continously low +B:1 + """ + self._cmd("ENABLE_BUSY_OFF", *args) + def set_data_output(self, *args): + """ Enable or disable printing of the received adc data to the console|dataout[bool]:disable or enable data output for received data (yes/no) +B:1 + """ + self._cmd("SET_DATA_OUTPUT", *args) + def block_transmission_range(self, *args): + """ Blocks the transmission of commands to the given range of slots. Use with care! For debugging pupose only!|first[short]:First slot to which the command transmission should be blocked (0-39)|last[short]:Last slot to which the command transmission should be blocked (0-39)|enable[bool]:Whether the command transmission should be blockes (yes) or allowed (no) +S:2;B:1 + """ + self._cmd("BLOCK_TRANSMISSION_RANGE", *args) + def events(self): + """ Event counts|evtsCount[int]:Num evts cur. run, total (all run), evt ID, trig. Num +I:4 + """ + return self._get("EVENTS") + def ignore_events_range(self, *args): + """ Instructs the event-builder to ignore events from the given slot but still read the data from the socket.|first[short]:First slot from which the data should be ignored when building events|last[short]:Last slot from which the data should be ignored when building events|enable[bool]:Whether the event builder should ignore data from this slot (yes) or allowed (no) +S:2;B:1 + """ + self._cmd("IGNORE_EVENTS_RANGE", *args) + def send_data(self, *args): + """ Send a command with data to the FADs. Values between 0 and 0xffff are allowed.|command[uint16]:Command to be transmittted.|data[uint16]:Data to be sent with the command. +I:2 + """ + self._cmd("SEND_DATA", *args) + def abort(self, *args): + """ Immediately abort EventBuilder thread and disconnect all slots. + + """ + self._cmd("ABORT", *args) + def reset_event_counter(self, *args): + """ Reset the FAD boards' event counter to 0. + + """ + self._cmd("RESET_EVENT_COUNTER", *args) + def set_hex_output(self, *args): + """ Enable or disable hex output for received data|hexout[bool]:disable or enable hex output for received data (yes/no) +B:1 + """ + self._cmd("SET_HEX_OUTPUT", *args) + def statistics1(self): + """ Event Builder status for GUI display|threadInfo[int]:Number of read, proc and writes|bufferInfo[int]:Events in buffer, incomp., comp., tot., max past cycle, total|memInfo[int]:total buf. mem, used mem, max used, max past cycle|EvtCnt[int]:Number of events skipped, written, with errors|badRoi[int]:Num boards with wrong ROI in event, run or board|badRoiBoard[int]:Num boards with wrong ROI|deltaT[ms]:Time in ms for rates|rateNew[int]:Number of new start events received|numConn[int]:Number of connections per board|errConn[int]:IO errors per board|rateBytes[int]:Bytes read this cycle|totBytes[int]:Bytes read (counter) +I:3;I:5;X:4;I:3;I:3;I:40;I:1;I:2;C:40;I:40;I:40;X:40 + """ + return self._get("STATISTICS1") + def enable_sclk(self, *args): + """ Set SCLK +B:1 + """ + self._cmd("ENABLE_SCLK", *args) + def enable_busy_on(self, *args): + """ Set BUSY constantly high (has priority over BUSY_OFF) +B:1 + """ + self._cmd("ENABLE_BUSY_ON", *args) + def set_region_of_interest(self, *args): + """ Set region-of-interest to value|channel[short]:Channel on each chip for which the ROI is set (0-8), -1 for all|val[short]:Value to be set +I:2 + """ + self._cmd("SET_REGION_OF_INTEREST", *args) + def set_trigger_rate(self, *args): + """ Enable continous trigger +I:1 + """ + self._cmd("SET_TRIGGER_RATE", *args) + def statistics2(self): + """ Event Builder status, events oriented|reset[int]:If increased, reset all counters|numRead[int]:How often sucessful read from N sockets per loop|gotByte[int]:number of bytes read per board|gotErr[int]:number of com. errors per board|evtStat[int]:number of evts read, completed, with errors, incomplete|procStat[int]:num. of evts proc., w probs, acc. or rej. by SW trigger|feedStat[int]:number of evts used or rejected by feedback system|wrtStat[int]:number of evts written to disk, with errors|runStat[int]:number of run opened, closed, with open or close errors|numConn[int]:number of sockets successfully opened per board +I:1;I:280;X:40;I:40;I:4;I:4;I:2;I:2;I:3;C:40 + """ + return self._get("STATISTICS2") + def service_desc(self): + """ Descriptions of services or commands and there arguments|Description[string]:For a detailed explanation of the descriptive string see the class reference of DimDescriptionService. +C + """ + return self._get("SERVICE_DESC") + def send_cmd(self, *args): + """ Send a command to the FADs. Values between 0 and 0xffff are allowed.|command[uint16]:Command to be transmittted. +I:1 + """ + self._cmd("SEND_CMD", *args) + def stop(self, *args): + """ Stop EventBuilder thread (still write buffered events) and disconnect all slots. + + """ + self._cmd("STOP", *args) + def connect(self, *args): + """ Connect a disconnected slot. +S:1 + """ + self._cmd("CONNECT", *args) + def send_single_trigger(self, *args): + """ Issue software triggers + + """ + self._cmd("SEND_SINGLE_TRIGGER", *args) + def dump_recv(self, *args): + """ For debugging purpose: the times when data has been receives are dumped to a file.|switch[bool]:Enable (yes) or disable (no) +B:1 + """ + self._cmd("DUMP_RECV", *args) + def enable_drs(self, *args): + """ Switch Domino wave +B:1 + """ + self._cmd("ENABLE_DRS", *args) + def start_drs_calibration(self, *args): + """ DESC in SERVICE_DESC is empty ?! + + """ + self._cmd("START_DRS_CALIBRATION", *args) + def start(self, *args): + """ Start EventBuilder thread and connect all valid slots. + + """ + self._cmd("START", *args) + def set_dac_value(self, *args): + """ Set DAC numbers in range to value|addr[short]:Address of register (-1 for all)|val[short]:Value to be set +I:2 + """ + self._cmd("SET_DAC_VALUE", *args) + def drs_calibration(self): + """ DESC in SERVICE_DESC is empty ?! +I:1;I:3;F:1474560;F:1474560;F:1474560;F:1474560;F:1474560;F:1474560;F:163840;F:163840 + """ + return self._get("DRS_CALIBRATION") + def dna(self): + """ DNA of FAD boards|DNA[hex]:Hex identifier of each FAD board +X:40 + """ + return self._get("DNA") + def configure(self, *args): + """ Configure a new run. If the internla trigger is enabled this might even start a new run.|time_max[s]:Maximum time before the run is closed in seconds (0: unlimited)|num_max[int]:Maximum number of events before the run is closed in seconds (0: unlimited)|run_type[string]:Run type which describes the runs +X:2;C + """ + self._cmd("CONFIGURE", *args) + def set_register(self, *args): + """ set register to value|addr[short]:Address of register|val[short]:Value to be set +I:2 + """ + self._cmd("SET_REGISTER", *args) + def enable_srclk(self, *args): + """ Set SRCLK +B:1 + """ + self._cmd("ENABLE_SRCLK", *args) + def send_n_triggers(self, *args): + """ Issue N software triggers (note that these are the triggers sent, not the triggers executed)|N[int]: Number of triggers to be sent to the board. +I + """ + self._cmd("SEND_N_TRIGGERS", *args) + def remove_slot(self, *args): + """ Remove the Iaddress in slot n. For a list see LIST|slot[short]:Remove the address in slot n from the list +S:1 + """ + self._cmd("REMOVE_SLOT", *args) + def set_verbose(self, *args): + """ Set verbosity state|verbosity[bool]:disable or enable verbosity for received data (yes/no), except dynamic data +B:1 + """ + self._cmd("SET_VERBOSE", *args) + def set_run_number(self, *args): + """ Sent a new run-number to the boards|num[int]:Run number +X:1 + """ + self._cmd("SET_RUN_NUMBER", *args) + def client_list(self): + """ Native Dim service: A list of all connected clients +C + """ + return self._get("CLIENT_LIST") + def enable_command_socket_mode(self, *args): + """ Set debug mode (yes: dump events through command socket, no=dump events through other sockets) +B:1 + """ + self._cmd("ENABLE_COMMAND_SOCKET_MODE", *args) + def state(self): + """ Provides the state of the state machine as quality of service.|Text[string]:A human readable string sent by the last state change. +C + """ + return self._get("STATE") + def exit(self, *args): + """ This is a native Dim command: Exit programremotely. FACT++ programs use the given number as return code.|Rc[int]:Return code, under normal circumstances this should be 0 or 1 (42 will call exit() directly, 0x42 will call abort() directly. +L:1 + """ + self._cmd("EXIT", *args) + def raw_data(self): + """ DESC in SERVICE_DESC is empty ?! +S:1;I:1;S:1;I:1;I:2;I:40;S:1440;S:160;F + """ + return self._get("RAW_DATA") + def list_slots(self, *args): + """ Print a list of all available board addressesa and whether they are enabled + + """ + self._cmd("LIST_SLOTS", *args) + def set_debug_event_builder_out(self, *args): + """ Enable or disable the debug output from the event builder|enable[bool]:Enable/Disable (yes/no) +B:1 + """ + self._cmd("SET_DEBUG_EVENT_BUILDER_OUT", *args) + def temperature(self): + """ FADs temperatures|temp[deg. C]:0 global min, 1-40 min, 41 global max, 42-81 max +F:82 + """ + return self._get("TEMPERATURE") + def dump_stream(self, *args): + """ For debugging purpose: the binary data stream read from the sockets 0-7 can be dumped to files.|switch[bool]:Enable (yes) or disable (no) +B:1 + """ + self._cmd("DUMP_STREAM", *args) + def region_of_interest(self): + """ DESC in SERVICE_DESC is empty ?! +S:2 + """ + return self._get("REGION_OF_INTEREST") + def ignore_events(self, *args): + """ Instructs the event-builder to ignore events from the given slot but still read the data from the socket.|slot[short]:Slot from which the data should be ignored when building events|enable[bool]:Whether the event builder should ignore data from this slot (yes) or allowed (no) +S:1;B:1 + """ + self._cmd("IGNORE_EVENTS", *args) + def start_run(self): + """ Run numbers|run[idx]:Run no of last conf'd run (-1 if reset or none config'd yet)|next[idx]:Run number which will be assigned to next configuration +X:1;X:1 + """ + return self._get("START_RUN") + def prescaler(self): + """ Trigger generator prescaler of fad boards|prescaler[int]:Trigger generator prescaler value, for each board +S:42 + """ + return self._get("PRESCALER") + def file_format(self): + """ DESC in SERVICE_DESC is empty ?! +S:1 + """ + return self._get("FILE_FORMAT") + def runs(self): + """ Run files statistics|stats[int]:num of open files, min/max run no, last opened or closed run|file[string]:filename of last opened file +I:5;C + """ + return self._get("RUNS") + def run_number(self): + """ Run numbers coming from FAD boards|runNumbers[int]:current run number of each FAD board. 40=min, 41=max +I:42 + """ + return self._get("RUN_NUMBER") + def service_list(self): + """ Native Dim service: List of services, commands and formats|ServiceList[string]:For details see the Dim manual. +C + """ + return self._get("SERVICE_LIST") + def toggle(self, *args): + """ DESC in SERVICE_DESC is empty ?! +S:1 + """ + self._cmd("TOGGLE", *args) + def reset_secondary_drs_baseline(self, *args): + """ DESC in SERVICE_DESC is empty ?! + + """ + self._cmd("RESET_SECONDARY_DRS_BASELINE", *args) + def message(self): + """ A general logging service providing a quality of service (severity)|Message[string]:The message +C + """ + return self._get("MESSAGE") + def close_open_files(self, *args): + """ Close all run files opened by the EventBuilder. + + """ + self._cmd("CLOSE_OPEN_FILES", *args) + def stats(self): + """ Statistics about size written +X:4 + """ + return self._get("STATS") + def soft_reset(self, *args): + """ Wait for buffers to drain, close all files and reinitialize event builder thread. + + """ + self._cmd("SOFT_RESET", *args) + def hard_reset(self, *args): + """ Free all buffers, close all files and reinitialize event builder thread. + + """ + self._cmd("HARD_RESET", *args) + def connections(self): + """ Connection status of FAD boards|status[bitpattern]:lower bits stat1, upper bits stat2, for every board. 40=thread|char[unknown]:to be completed +C:40;C:1 + """ + return self._get("CONNECTIONS") + def reset_configure(self, *args): + """ If configuration failed and the fadctrl is waiting for something, use this to reset the state. + + """ + self._cmd("RESET_CONFIGURE", *args) +class MAGIC_WEATHER ( FactDimServer): + def version_number(self): + """ Native Dim service: Version number of Dim in use|DimVer[int]:Version*100+Release (e.g. V19r17 = 1917) +L + """ + return self._get("VERSION_NUMBER") + def service_list(self): + """ Native Dim service: List of services, commands and formats|ServiceList[string]:For details see the Dim manual. +C + """ + return self._get("SERVICE_LIST") + def client_list(self): + """ Native Dim service: A list of all connected clients +C + """ + return self._get("CLIENT_LIST") + def state(self): + """ Provides the state of the state machine as quality of service.|Text[string]:A human readable string sent by the last state change. +C + """ + return self._get("STATE") + def data(self): + """ |stat:Status|T[deg C]:Temperature|T_dew[deg C]:Dew point|H[%]:Humidity|P[hPa]:Air pressure|v[km/h]:Wind speed|v_max[km/h]:Wind gusts|d[deg]:Wind direction (N-E) +S:1;F:1;F:1;F:1;F:1;F:1;F:1;F:1 + """ + return self._get("DATA") + def message(self): + """ A general logging service providing a quality of service (severity)|Message[string]:The message +C + """ + return self._get("MESSAGE") + def state_list(self): + """ Provides a list with descriptions for each service.|StateList[string]:A \n separated list of the form id:name=description +C + """ + return self._get("STATE_LIST") + def set_verbose(self, *args): + """ set verbosity state|verbosity[bool]:disable or enable verbosity for received data (yes/no), except dynamic data +B + """ + self._cmd("SET_VERBOSE", *args) + def service_desc(self): + """ Descriptions of services or commands and there arguments|Description[string]:For a detailed explanation of the descriptive string see the class reference of DimDescriptionService. +C + """ + return self._get("SERVICE_DESC") + def exit(self, *args): + """ This is a native Dim command: Exit programremotely. FACT++ programs use the given number as return code.|Rc[int]:Return code, under normal circumstances this should be 0 or 1 (42 will call exit() directly, 0x42 will call abort() directly. +L:1 + """ + self._cmd("EXIT", *args) +class CHAT ( FactDimServer): + def exit(self, *args): + """ This is a native Dim command: Exit programremotely. FACT++ programs use the given number as return code.|Rc[int]:Return code, under normal circumstances this should be 0 or 1 (42 will call exit() directly, 0x42 will call abort() directly. +L:1 + """ + self._cmd("EXIT", *args) + def client_list(self): + """ Native Dim service: A list of all connected clients +C + """ + return self._get("CLIENT_LIST") + def state_list(self): + """ Provides a list with descriptions for each service.|StateList[string]:A \n separated list of the form id:name=description +C + """ + return self._get("STATE_LIST") + def version_number(self): + """ Native Dim service: Version number of Dim in use|DimVer[int]:Version*100+Release (e.g. V19r17 = 1917) +L + """ + return self._get("VERSION_NUMBER") + def service_desc(self): + """ Descriptions of services or commands and there arguments|Description[string]:For a detailed explanation of the descriptive string see the class reference of DimDescriptionService. +C + """ + return self._get("SERVICE_DESC") + def msg(self, *args): + """ |msg[string]:message to be distributed +C + """ + self._cmd("MSG", *args) + def state(self): + """ Provides the state of the state machine as quality of service.|Text[string]:A human readable string sent by the last state change. +C + """ + return self._get("STATE") + def service_list(self): + """ Native Dim service: List of services, commands and formats|ServiceList[string]:For details see the Dim manual. +C + """ + return self._get("SERVICE_LIST") + def message(self): + """ A general logging service providing a quality of service (severity)|Message[string]:The message +C + """ + return self._get("MESSAGE") +class DRIVE_CONTROL ( FactDimServer): + def track_on(self, *args): + """ Move the telescope to the given position and start tracking|Name[string]:Source name +C + """ + self._cmd("TRACK_ON", *args) + def status(self): + """ DESC in SERVICE_DESC is empty ?! +C:2;C:1 + """ + return self._get("STATUS") + def state_list(self): + """ Provides a list with descriptions for each service.|StateList[string]:A \n separated list of the form id:name=description +C + """ + return self._get("STATE_LIST") + def set_led_brightness(self, *args): + """ Set the LED brightness of the top and bottom leds|top[au]:Allowed range 0-32767 for top LEDs|bot[au]:Allowed range 0-32767 for bottom LEDs +I:2 + """ + self._cmd("SET_LED_BRIGHTNESS", *args) + def track_wobble(self, *args): + """ Move the telescope to the given wobble position around the given source and start tracking|id:Wobble angle id (1 or 2)|Name[string]:Source name +S:1;C + """ + self._cmd("TRACK_WOBBLE", *args) + def wobble(self, *args): + """ Move the telescope to the given wobble position around the given sky coordinates and start tracking them|Ra[h]:Right ascension|Dec[deg]:Declination|Offset[deg]:Wobble offset|Angle[deg]:Wobble angle +D:4 + """ + self._cmd("WOBBLE", *args) + def source_position(self): + """ |Ra_src[h]:Source right ascension|Dec_src[deg]:Source declination|Ra_cmd[h]:Command right ascension|Dec_cmd[deg]:Command declination|Offset[deg]:Wobble offset|Angle[deg]:Wobble angle|Name[string]:Source name if available +D:1;D:1;D:1;D:1;D:1;D:1;C:31 + """ + return self._get("SOURCE_POSITION") + def move_to(self, *args): + """ Move the telescope to the given local coordinates|Zd[deg]:Zenith distance|Az[deg]:Azimuth +D:2 + """ + self._cmd("MOVE_TO", *args) + def stop(self, *args): + """ Stop any kind of movement. + + """ + self._cmd("STOP", *args) + def leds_off(self, *args): + """ Switch off TPoint LEDs + + """ + self._cmd("LEDS_OFF", *args) + def jupiter(self, *args): + """ Start tracking Jupiter + + """ + self._cmd("JUPITER", *args) + def park(self, *args): + """ Park the telescope + + """ + self._cmd("PARK", *args) + def service_desc(self): + """ Descriptions of services or commands and there arguments|Description[string]:For a detailed explanation of the descriptive string see the class reference of DimDescriptionService. +C + """ + return self._get("SERVICE_DESC") + def service_list(self): + """ Native Dim service: List of services, commands and formats|ServiceList[string]:For details see the Dim manual. +C + """ + return self._get("SERVICE_LIST") + def moon(self, *args): + """ Start tracking the moon + + """ + self._cmd("MOON", *args) + def reload_sources(self, *args): + """ Reload sources from database after database has changed.. + + """ + self._cmd("RELOAD_SOURCES", *args) + def exit(self, *args): + """ This is a native Dim command: Exit programremotely. FACT++ programs use the given number as return code.|Rc[int]:Return code, under normal circumstances this should be 0 or 1 (42 will call exit() directly, 0x42 will call abort() directly. +L:1 + """ + self._cmd("EXIT", *args) + def print_cmd(self, *args): + """ Print source list. + + """ + self._cmd("PRINT_CMD", *args) + def set_verbose(self, *args): + """ Set verbosity state|verbosity[bool]:disable or enable verbosity for received data (yes/no), except dynamic data +B + """ + self._cmd("SET_VERBOSE", *args) + def message(self): + """ A general logging service providing a quality of service (severity)|Message[string]:The message +C + """ + return self._get("MESSAGE") + def resume(self, *args): + """ If drive is in Error state, this can b used to resume the last tracking command, if the last command sent to cosy was a tracking command. + + """ + self._cmd("RESUME", *args) + def tpoint(self): + """ Take a TPoint (given values will be written to the TPoint files)|mag[float]:Magnitude of the star|name[string]:Name of the star +D:1;D:1;D:1;D:1;D:1;D:1;D:1;D:1;S:1;D:1;D:1;D:1;D:1;D:1;D:1;D:1;C + """ + return self._get("TPOINT") + def set_autoresume(self, *args): + """ Enable/disable auto resume|resume[bool]:if enabled, drive is tracking and goes to error state, the last tracking command is repeated automatically. +B + """ + self._cmd("SET_AUTORESUME", *args) + def reconnect(self, *args): + """ (Re)connect ethernet connection to FTM, a new address can be given|[host][string]:new ethernet address in the form +O + """ + self._cmd("RECONNECT", *args) + def tracking_position(self): + """ |Ra[h]:Command right ascension|Dec[deg]:Command declination|Ha[h]:Corresponding hour angle|Zd[deg]:Nominal zenith distance|Az[deg]:Nominal azimuth angle|dZd[deg]:Control deviation Zd|dAz[deg]:Control deviation Az|dev[arcsec]:Absolute control deviation +D:1;D:1;D:1;D:1;D:1;D:1;D:1;D:1 + """ + return self._get("TRACKING_POSITION") + def venus(self, *args): + """ Start tracking Venus + + """ + self._cmd("VENUS", *args) + def take_tpoint(self, *args): + """ Take a TPoint + + """ + self._cmd("TAKE_TPOINT", *args) + def disconnect(self, *args): + """ disconnect from ethernet + + """ + self._cmd("DISCONNECT", *args) + def saturn(self, *args): + """ Start tracking Saturn + + """ + self._cmd("SATURN", *args) + def unlock(self, *args): + """ Unlock locked state. + + """ + self._cmd("UNLOCK", *args) + def state(self): + """ Provides the state of the state machine as quality of service.|Text[string]:A human readable string sent by the last state change. +C + """ + return self._get("STATE") + def pointing_position(self): + """ |Zd[deg]:Zenith distance (encoder readout)|Az[deg]:Azimuth angle (encoder readout) +D:1;D:1 + """ + return self._get("POINTING_POSITION") + def track(self, *args): + """ Move the telescope to the given sky coordinates and start tracking them|Ra[h]:Right ascension|Dec[deg]:Declination +D:2 + """ + self._cmd("TRACK", *args) + def client_list(self): + """ Native Dim service: A list of all connected clients +C + """ + return self._get("CLIENT_LIST") + def mars(self, *args): + """ Start tracking Mars + + """ + self._cmd("MARS", *args) + def track_source(self, *args): + """ Move the telescope to the given wobble position around the given source and start tracking|Offset[deg]:Wobble offset|Angle[deg]:Wobble angle|Name[string]:Source name +D:2;C + """ + self._cmd("TRACK_SOURCE", *args) + def version_number(self): + """ Native Dim service: Version number of Dim in use|DimVer[int]:Version*100+Release (e.g. V19r17 = 1917) +L + """ + return self._get("VERSION_NUMBER") +class SMART_FACT ( FactDimServer): + def print_cmd(self, *args): + """ Print a list of the states of all connected servers. + + """ + self._cmd("PRINT_CMD", *args) + def service_list(self): + """ Native Dim service: List of services, commands and formats|ServiceList[string]:For details see the Dim manual. +C + """ + return self._get("SERVICE_LIST") + def version_number(self): + """ Native Dim service: Version number of Dim in use|DimVer[int]:Version*100+Release (e.g. V19r17 = 1917) +L + """ + return self._get("VERSION_NUMBER") + def client_list(self): + """ Native Dim service: A list of all connected clients +C + """ + return self._get("CLIENT_LIST") + def service_desc(self): + """ Descriptions of services or commands and there arguments|Description[string]:For a detailed explanation of the descriptive string see the class reference of DimDescriptionService. +C + """ + return self._get("SERVICE_DESC") + def exit(self, *args): + """ This is a native Dim command: Exit programremotely. FACT++ programs use the given number as return code.|Rc[int]:Return code, under normal circumstances this should be 0 or 1 (42 will call exit() directly, 0x42 will call abort() directly. +L:1 + """ + self._cmd("EXIT", *args) + def message(self): + """ A general logging service providing a quality of service (severity)|Message[string]:The message +C + """ + return self._get("MESSAGE") + def state(self): + """ Provides the state of the state machine as quality of service.|Text[string]:A human readable string sent by the last state change. +C + """ + return self._get("STATE") + def state_list(self): + """ Provides a list with descriptions for each service.|StateList[string]:A \n separated list of the form id:name=description +C + """ + return self._get("STATE_LIST") +class MCP ( FactDimServer): + def message(self): + """ A general logging service providing a quality of service (severity)|Message[string]:The message +C + """ + return self._get("MESSAGE") + def state_list(self): + """ Provides a list with descriptions for each service.|StateList[string]:A \n separated list of the form id:name=description +C + """ + return self._get("STATE_LIST") + def version_number(self): + """ Native Dim service: Version number of Dim in use|DimVer[int]:Version*100+Release (e.g. V19r17 = 1917) +L + """ + return self._get("VERSION_NUMBER") + def print_cmd(self, *args): + """ Print the states and connection status of all systems connected to the MCP. + + """ + self._cmd("PRINT_CMD", *args) + def exit(self, *args): + """ This is a native Dim command: Exit programremotely. FACT++ programs use the given number as return code.|Rc[int]:Return code, under normal circumstances this should be 0 or 1 (42 will call exit() directly, 0x42 will call abort() directly. +L:1 + """ + self._cmd("EXIT", *args) + def client_list(self): + """ Native Dim service: A list of all connected clients +C + """ + return self._get("CLIENT_LIST") + def stop(self, *args): + """ Stops the trigger (either disables the FTM trigger or the internal DRS trigger) + + """ + self._cmd("STOP", *args) + def service_list(self): + """ Native Dim service: List of services, commands and formats|ServiceList[string]:For details see the Dim manual. +C + """ + return self._get("SERVICE_LIST") + def service_desc(self): + """ Descriptions of services or commands and there arguments|Description[string]:For a detailed explanation of the descriptive string see the class reference of DimDescriptionService. +C + """ + return self._get("SERVICE_DESC") + def start(self, *args): + """ Start the configuration and data taking for a run-type of a pre-defined setup|TimeMax[s]:Maximum number of seconds before the run will be closed automatically|NumMax[count]:Maximum number events before the run will be closed automatically|Name[text]:Name of the configuration to be used for taking data +X:2;C + """ + self._cmd("START", *args) + def reset(self, *args): + """ If a configuration blockes because a system cannot configure itself properly, this command can be called to leave the configuration procedure. The command is also propagated to FTM and FAD + + """ + self._cmd("RESET", *args) + def configuration(self): + """ Run configuration information|MaxTime[s]:Maximum time before the run gets stopped|MaxEvents[num]:Maximum number of events before the run gets stopped|Name[text]:Name of the chosen configuration +X:1;X:1;C + """ + return self._get("CONFIGURATION") + def state(self): + """ Provides the state of the state machine as quality of service.|Text[string]:A human readable string sent by the last state change. +C + """ + return self._get("STATE") +class TIME_CHECK ( FactDimServer): + def message(self): + """ A general logging service providing a quality of service (severity)|Message[string]:The message +C + """ + return self._get("MESSAGE") + def exit(self, *args): + """ This is a native Dim command: Exit programremotely. FACT++ programs use the given number as return code.|Rc[int]:Return code, under normal circumstances this should be 0 or 1 (42 will call exit() directly, 0x42 will call abort() directly. +L:1 + """ + self._cmd("EXIT", *args) + def state(self): + """ Provides the state of the state machine as quality of service.|Text[string]:A human readable string sent by the last state change. +C + """ + return self._get("STATE") + def service_list(self): + """ Native Dim service: List of services, commands and formats|ServiceList[string]:For details see the Dim manual. +C + """ + return self._get("SERVICE_LIST") + def version_number(self): + """ Native Dim service: Version number of Dim in use|DimVer[int]:Version*100+Release (e.g. V19r17 = 1917) +L + """ + return self._get("VERSION_NUMBER") + def state_list(self): + """ Provides a list with descriptions for each service.|StateList[string]:A \n separated list of the form id:name=description +C + """ + return self._get("STATE_LIST") + def service_desc(self): + """ Descriptions of services or commands and there arguments|Description[string]:For a detailed explanation of the descriptive string see the class reference of DimDescriptionService. +C + """ + return self._get("SERVICE_DESC") + def client_list(self): + """ Native Dim service: A list of all connected clients +C + """ + return self._get("CLIENT_LIST") +class BIAS_CONTROL ( FactDimServer): + def dac(self): + """ |U[dac]:Current dac setting|Uref[dac]:Reference dac setting +S:416;S:416 + """ + return self._get("DAC") + def set_channel_dac(self, *args): + """ Set a new target value in DAC counts for a single channel. Starts ramping if necessary.|channel[short]:Channel for which to set the target voltage [0-415]|voltage[dac]:Target voltage in DAC units for the given channel +S:1;S:1 + """ + self._cmd("SET_CHANNEL_DAC", *args) + def request_status(self, *args): + """ Asynchronously request the status (current) of all channels. + + """ + self._cmd("REQUEST_STATUS", *args) + def expert_reset(self, *args): + """ Send the RESET command (note that this is possibly harmfull command) + + """ + self._cmd("EXPERT_RESET", *args) + def increase_all_channels_voltage(self, *args): + """ Add the given voltages to the current reference voltages. Starts ramping if necessary.offset[V]:Offsets to be added to the reference voltage of all channels in volts +F:416 + """ + self._cmd("INCREASE_ALL_CHANNELS_VOLTAGE", *args) + def reset_over_current_status(self, *args): + """ Set all channels in over current state to 0V and send a system reset to reset the over current flags. + + """ + self._cmd("RESET_OVER_CURRENT_STATUS", *args) + def print_currents(self, *args): + """ Print a table with all current read back with the last request operation + + """ + self._cmd("PRINT_CURRENTS", *args) + def print_info(self, *args): + """ Print a table with all current read back with the last request operation + + """ + self._cmd("PRINT_INFO", *args) + def reconnect(self, *args): + """ (Re)connect USB connection to Bias power supply, a new address can be given|tty[string]:new USB address +O + """ + self._cmd("RECONNECT", *args) + def enable_dummy_mode(self, *args): + """ Enable dummy mode. In this mode SetAllChannels prints informations instead of sending anything to the bias crate.|enable[bool]:disable or enable dummy mode +B:1 + """ + self._cmd("ENABLE_DUMMY_MODE", *args) + def set_channel_offset_to_zero(self, *args): + """ Set a single channel channels to its G-APD reference voltage. Starts ramping if necessary.|channel[short]:Channel for which to set the target voltage [0-416] +S:1 + """ + self._cmd("SET_CHANNEL_OFFSET_TO_ZERO", *args) + def exit(self, *args): + """ This is a native Dim command: Exit programremotely. FACT++ programs use the given number as return code.|Rc[int]:Return code, under normal circumstances this should be 0 or 1 (42 will call exit() directly, 0x42 will call abort() directly. +L:1 + """ + self._cmd("EXIT", *args) + def set_channel_voltage(self, *args): + """ Set a new target voltage for a single channel. Starts ramping if necessary.|channel[short]:Channel for which to set the target voltage [0-415]|voltage[V]:Target voltage in volts for the given channel (will be converted to DAC units) +S:1;F:1 + """ + self._cmd("SET_CHANNEL_VOLTAGE", *args) + def set_global_dac(self, *args): + """ Set a new target value for all channels in DAC counts. Starts ramping if necessary. (This command is not realized with the GLOBAL SET command.)|voltage[dac]:Global target voltage in DAC counts. +S:1 + """ + self._cmd("SET_GLOBAL_DAC", *args) + def set_all_channels_voltage(self, *args): + """ Set all channels to the given new reference voltage. Starts ramping if necessary.voltage[V]:New reference voltage for all channels +F:416 + """ + self._cmd("SET_ALL_CHANNELS_VOLTAGE", *args) + def voltage(self): + """ |Uout[V]:Output voltage +F:416 + """ + return self._get("VOLTAGE") + def stop(self, *args): + """ Stop an on-going ramping + + """ + self._cmd("STOP", *args) + def expert_set_channel_voltage(self, *args): + """ Send a single channel set command. The given voltage is converted to DAC commands. +S:1;F:1 + """ + self._cmd("EXPERT_SET_CHANNEL_VOLTAGE", *args) + def set_zero_voltage(self, *args): + """ Set all channels to a zero reference voltage. Starts ramping if necessary. + + """ + self._cmd("SET_ZERO_VOLTAGE", *args) + def client_list(self): + """ Native Dim service: A list of all connected clients +C + """ + return self._get("CLIENT_LIST") + def print_voltages(self, *args): + """ Print a table with all voltages (current and reference voltages as currently in memory) + + """ + self._cmd("PRINT_VOLTAGES", *args) + def increase_global_voltage(self, *args): + """ Increases the voltage of all channels by the given offset. Starts ramping if necessary. (This command is not realized with the GLOBAL SET command.)|offset[V]:Offset to be added to all channels (will be converted to DAC counts) +F:1 + """ + self._cmd("INCREASE_GLOBAL_VOLTAGE", *args) + def set_global_voltage(self, *args): + """ Set a new target voltage for all channels. Starts ramping if necessary. (This command is not realized with the GLOBAL SET command.)|voltage[V]:Global target voltage in volts (will be converted to DAC units) +F:1 + """ + self._cmd("SET_GLOBAL_VOLTAGE", *args) + def state_list(self): + """ Provides a list with descriptions for each service.|StateList[string]:A \n separated list of the form id:name=description +C + """ + return self._get("STATE_LIST") + def expert_set_global_dac(self, *args): + """ Send the global set command. +S:1 + """ + self._cmd("EXPERT_SET_GLOBAL_DAC", *args) + def nominal(self): + """ |Ubr[V]:Nominal breakdown voltage at 25deg C|Uov[V]:Nominal overvoltage|Uoff[V]:Bias crate channel offsets +F:416;F:416;F:416 + """ + return self._get("NOMINAL") + def set_update_interval(self, *args): + """ Set the updat einterval how often the currents are requested|interval[ms]:Update interval in milliseconds +I:1 + """ + self._cmd("SET_UPDATE_INTERVAL", *args) + def expert_set_channel_dac(self, *args): + """ Send a single channel set command. +S:1;S:1 + """ + self._cmd("EXPERT_SET_CHANNEL_DAC", *args) + def increase_channel_voltage(self, *args): + """ Increases the voltage of all channels by the given offset. Starts ramping if necessary. (This command is not realized with the GLOBAL SET command.)|channel[short]:Channel for which to adapt the voltage [0-415]|offset[V]:Offset to be added to all channels (will be converted to DAC counts) +S:1;F:1 + """ + self._cmd("INCREASE_CHANNEL_VOLTAGE", *args) + def set_all_channels_offset(self, *args): + """ Set all channels to their G-APD reference voltage plus the given offset. Starts ramping if necessary.|offset[V]:Offset to be added to teh G-APD reference voltage globally +F:416 + """ + self._cmd("SET_ALL_CHANNELS_OFFSET", *args) + def set_global_offset_to_zero(self, *args): + """ Set all channels to their G-APD reference voltage. Starts ramping if necessary. + + """ + self._cmd("SET_GLOBAL_OFFSET_TO_ZERO", *args) + def set_global_offset(self, *args): + """ Set all channels to their G-APD breakdown voltage plus overvoltage plus the given offset. Starts ramping if necessary.|offset[V]:Offset to be added to the G-APD reference voltage globally +F:1 + """ + self._cmd("SET_GLOBAL_OFFSET", *args) + def current(self): + """ |I[dac]:Bias current (conversion: 5000uA/4096dac) +S:416 + """ + return self._get("CURRENT") + def service_desc(self): + """ Descriptions of services or commands and there arguments|Description[string]:For a detailed explanation of the descriptive string see the class reference of DimDescriptionService. +C + """ + return self._get("SERVICE_DESC") + def message(self): + """ A general logging service providing a quality of service (severity)|Message[string]:The message +C + """ + return self._get("MESSAGE") + def state(self): + """ Provides the state of the state machine as quality of service.|Text[string]:A human readable string sent by the last state change. +C + """ + return self._get("STATE") + def print_gapd_reference_voltages(self, *args): + """ Print the G-APD reference values (breakdown voltage + overvoltage) obtained from file + + """ + self._cmd("PRINT_GAPD_REFERENCE_VOLTAGES", *args) + def set_verbose(self, *args): + """ set verbosity state|verbosity[bool]:disable or enable verbosity for received data (yes/no), except dynamic data +B:1 + """ + self._cmd("SET_VERBOSE", *args) + def service_list(self): + """ Native Dim service: List of services, commands and formats|ServiceList[string]:For details see the Dim manual. +C + """ + return self._get("SERVICE_LIST") + def expert_mode(self, *args): + """ Enable usage of expert commands (note that for safty reasons the are exclusive with the standard commands) +B:1 + """ + self._cmd("EXPERT_MODE", *args) + def expert_set_global_voltage(self, *args): + """ Send the global set command. The given voltage is converted to DAC counts. +F:1 + """ + self._cmd("EXPERT_SET_GLOBAL_VOLTAGE", *args) + def set_channel_offset(self, *args): + """ Set single channels to its G-APD breakdown voltage plus overvoltage plus the given offset. Starts ramping if necessary.|channel[short]:Channel for which to set the target voltage [0-415]|offset[V]:Offset to be added to the G-APD reference voltage of the given channel +S:1;F:1 + """ + self._cmd("SET_CHANNEL_OFFSET", *args) + def start(self, *args): + """ Start a ramping if no ramping is in progress and if reference values differ from current voltages + + """ + self._cmd("START", *args) + def version_number(self): + """ Native Dim service: Version number of Dim in use|DimVer[int]:Version*100+Release (e.g. V19r17 = 1917) +L + """ + return self._get("VERSION_NUMBER") + def disconnect(self, *args): + """ disconnect from USB + + """ + self._cmd("DISCONNECT", *args) +class DIM_CONTROL ( FactDimServer): + def service_list(self): + """ Native Dim service: List of services, commands and formats|ServiceList[string]:For details see the Dim manual. +C + """ + return self._get("SERVICE_LIST") + def message(self): + """ A general logging service providing a quality of service (severity)|Message[string]:The message +C + """ + return self._get("MESSAGE") + def start(self, *args): + """ Start a JavaScript +C + """ + self._cmd("START", *args) + def stop(self, *args): + """ Stop a runnning batch script or JavaScript +C + """ + self._cmd("STOP", *args) + def state(self): + """ Provides the state of the state machine as quality of service.|Text[string]:A human readable string sent by the last state change. +C + """ + return self._get("STATE") + def client_list(self): + """ Native Dim service: A list of all connected clients +C + """ + return self._get("CLIENT_LIST") + def exit(self, *args): + """ This is a native Dim command: Exit programremotely. FACT++ programs use the given number as return code.|Rc[int]:Return code, under normal circumstances this should be 0 or 1 (42 will call exit() directly, 0x42 will call abort() directly. +L:1 + """ + self._cmd("EXIT", *args) + def execute(self, *args): + """ Execute a batch script +C + """ + self._cmd("EXECUTE", *args) + def service_desc(self): + """ Descriptions of services or commands and there arguments|Description[string]:For a detailed explanation of the descriptive string see the class reference of DimDescriptionService. +C + """ + return self._get("SERVICE_DESC") + def state_list(self): + """ Provides a list with descriptions for each service.|StateList[string]:A \n separated list of the form id:name=description +C + """ + return self._get("STATE_LIST") + def version_number(self): + """ Native Dim service: Version number of Dim in use|DimVer[int]:Version*100+Release (e.g. V19r17 = 1917) +L + """ + return self._get("VERSION_NUMBER") Index: fact/tools/PyDimCtrl/factdimserver.py =================================================================== --- fact/tools/PyDimCtrl/factdimserver.py (revision 14660) +++ fact/tools/PyDimCtrl/factdimserver.py (revision 14788) @@ -16,5 +16,6 @@ # using this line makes 'export DIM_DNS_NODE=daq' obsolete -pydim.dic_set_dns_node('daq') +#pydim.dic_set_dns_node('daq') +pydim.dic_set_dns_node('newdaq') class FactDimServer( object ): Index: fact/tools/PyDimCtrl/make_fix_dimservers.py =================================================================== --- fact/tools/PyDimCtrl/make_fix_dimservers.py (revision 14788) +++ fact/tools/PyDimCtrl/make_fix_dimservers.py (revision 14788) @@ -0,0 +1,402 @@ +#!/usr/bin/python -tti + +# for tab completion +import rlcompleter +import readline +readline.parse_and_bind('tab: complete') + +import sys # for sys.exit() during bebugging mostly :-) +import types # for dynamic class construction +import time # for time.sleep +from pprint import pprint # for nice printing + +from keyword import iskeyword # in case dynamic methods are equal to keywords + +import pydim # for the C-API Dim Call Wrappers + +# using this line makes 'export DIM_DNS_NODE=daq' obsolete +#pydim.dic_set_dns_node('daq') +pydim.dic_set_dns_node('newdaq') + +def print_command( name, f ): + meth_name = name.split('/')[1].lower() + if iskeyword(meth_name): + meth_name += '_cmd' + + if name in dd: + if not dd[name]: + doc_string = "DESC in SERVICE_DESC is empty ?!" + else: + doc_string = dd[name] + else: + doc_string = "-- no DESC found in SERVICE_DESC --" + doc_string += '\n' + doc_string += services[name.split('/')[0]][name][0] + + + # this is the new command, it simply calls the _cmd() method + f.write(" def " + meth_name + "(self, *args):\n" ) + f.write(' """ ' + doc_string +'\n' ) + f.write(' """ \n') + f.write(' self._cmd("' + meth_name.upper() + '", *args)\n' ) + +def print_getter( name, f ): + meth_name = name.split('/')[1].lower() + if iskeyword(meth_name): + meth_name += '_get' + + if name in dd: + if not dd[name]: + doc_string = "DESC in SERVICE_DESC is empty ?!" + else: + doc_string = dd[name] + else: + doc_string = "-- no DESC found in SERVICE_DESC --" + doc_string += '\n' + doc_string += services[name.split('/')[0]][name][0] + + + # this is the new command, it simply calls the _cmd() method + f.write(" def " + meth_name + "(self):\n" ) + f.write(' """ ' + doc_string+ '\n') + f.write(' """ \n') + f.write(' return self._get("' + meth_name.upper() + '")\n' ) + + + + +class FactDimServer( object ): + def __init__(self, name): + """ sets name of instance to name of server, all uppercase + """ + self.list_of_states = [] + self.name = name.upper() + self.print_state = False + self.print_msg = False + self.reg_state_cb() + self.reg_msg_cb() + self.user_func = None + self.__delay_between_cmds = 1.0 + self.__delay_between_services = 1.0 + self.__last_cmd_send = -1*float('inf') + self.__last_service_got = -1*float('inf') + + def _cmd(self, cmdstr, *args): + """ used by all dynamicly created methods, which call a Dim CMD + """ + cmdstr=self.name+'/'+cmdstr.upper() + desc = services[self.name][cmdstr.upper()][0] + + # there is a work around for a bug in pydim + # even if a command needs no argument, and desc is also empty string + # one has to give one ... need to tell Niko about it. + if not desc: + desc = 'I' + args=(1,) + elif desc == 'O': + args = (0,) + while not time.time() - self.__last_cmd_send > self.__delay_between_cmds: + time.sleep(0.5) + self.__last_cmd_send = time.time() + pydim.dic_sync_cmnd_service(cmdstr, args, desc, timeout=1) + + + + def _get(self, service): + """ used by all dynamicly created methods, which get a service + """ + full_srv_name = self.name+'/'+service.upper() + desc = services[self.name][full_srv_name][0] + + while not time.time() - self.__last_service_got > self.__delay_between_services: + time.sleep(0.5) + self.__last_service_got = time.time() + #print 'full_srv_name',full_srv_name + #print 'desc', desc + return pydim.dic_sync_info_service(full_srv_name, desc, timeout=1) + + + + def __call__(self): + """ Wrapper / For Convenience + self.state() returns a string (if it exists) + *returns* numeric state code, parsed from return of self.state() + """ + if hasattr(self, 'stn'): + return self.stn + else: + raise TypeError(self.name+' has no CMD called STATE') + + def wait(self, state_num, timeout=None): + """ waits for a certain state + BLOCKING + returns True if state was reached + returns False if timeout occured + raises TypeError if Server has no method state + """ + + if not hasattr(self, 'stn'): + raise TypeError(self.name+' has no CMD called STATE') + if timeout == None: + timeout = float('inf') + else: + timeout = float(timeout) + start = time.time() + while not self.stn == state_num: + time.sleep(0.1) + if time.time() >= start+timeout: + return False + return True + + def state_callback(self, state): + self.sts = state + try: + self.stn = int(state[state.find('[')+1 : state.find(']')]) + except ValueError: + self.stn = None + + self.last_st_change = time.time() + self.list_of_states.append( (self.last_st_change, self.stn) ) + if len(self.list_of_states) > 10000: + print "list_of_states too long, truncating..." + self.list_of_states = self.list_of_states[1000:] + + if self.user_func: + self.user_func( self.stn ) + + if self.print_state: + print state + + def msg_callback(self, msg): + if self.print_msg: + print msg + + def reg_state_cb(self): + if not hasattr(self, 'state'): + raise TypeError(self.name+' has no CMD called STATE') + service_name = self.name.upper()+'/STATE' + self.state_sid = pydim.dic_info_service(service_name, "C", self.state_callback) + if not self.state_sid: + del self.state_sid + raise IOError('could not register STATE client') + + def reg_msg_cb(self): + if not hasattr(self, 'state'): + raise TypeError(self.name+' has no CMD called STATE') + service_name = self.name.upper()+'/MESSAGE' + self.msg_sid = pydim.dic_info_service(service_name, "C", self.msg_callback) + if not self.msg_sid: + del self.msg_sid + raise IOError('could not register MESSAGE client') + + def unreg_state_cb(self): + if hasattr(self, 'state_sid'): + pydim.dic_release_service(self.state_sid) + del self.state_sid + + def unreg_msg_cb(self): + if hasattr(self, 'msg_sid'): + pydim.dic_release_service(self.msg_sid) + del self.msg_sid + + def __del__(self): + self.unreg_state_cb() + self.unreg_msg_cb() + + + +# In order to create classes according to the Dim-Servers, currently connected +# to the DIS_DNS I have to parse DIS_DNS/SERVER_LIST +# This is done in two steps, first I get the list of Server Names from DIS_DNS +# and the I get the list of each servers services and cmds, +# from each servers SERVICE_LIST and the service/command description +# from each servers SERVICE_DESC +# I get quite a lot of information, which I store in python dicts, or +# even nested dicts, if necessary. +def ParseDnsServerList( timeout = 5): + """ requests DIS_DNS/SERVER_LSIT and creates dict *servers* from it, + which is returned as well. + + the returned dict contains: + { "SERVER_NAME": (pid_of_server_process, host_the_server_runs_on) } + + the SERVER_NAME seems to be in capital letter all the time, but I'm + not sure if this is really ensured by Dim or if this was ensured by + Thomas manually. So maybe one should not rely on this. + + In case the request of DIS_DNS/SERVER_LIST times out, no Exception + is thrown, but the program exits. This is probably bullshit. + """ + # making server list + rawlist = pydim.dic_sync_info_service('DIS_DNS/SERVER_LIST','C', timeout=5) + if rawlist == None: + ## todo: throw an exception here! + print "couldn't get the server list of DIS_DNS. program abortion..." + sys.exit(1) + #print rawlist + # the output needs to be treated a bit .. it is a tuple with only one long string in it + # the string contains | and the strange character \x00 (ascii-zero) + # I use both to cut the list apart + rawlist = rawlist[0].split('\x00') + servers_n_hosts = rawlist[0].split('|') + server_ids = rawlist[1].split('|') + + servers = {} + for i,snh in enumerate(servers_n_hosts): + snh = snh.split('@') + s = snh[0] + h = snh[1] + sid = server_ids[i] + servers[s] = (sid, h) + + return servers + + + +# servers should be a dict containing uppercase server names as keys, +# the dict-values are not needed, so it might be any iteratable python listlike type +# to be precise +def ParseServersServiceList( servers ): + """ this function parses SERVER_NAME/SERVICE_LIST as well as + SERVER_NAME/SERVICE_DESC of all SERVER_NAME in the input list-like *servers* + + two dicts are returned: + *services* - nested dict: + { "SERVER_NAME" : { "SERVER_NAME/SERVICE_NAME" : ( + "format-description-string like: I:2;C", + "" or "CMP" or "RPC", + "service description text" ) } } + + *dd* - normal dict: + { "SERVER_NAME/SERVICE_NAME" : "service description text" } + + """ + + services = {} + dd = {} + for server in servers: + # sl_raw is a tuple, with one really long string, which needs to be parsed + sl_raw = pydim.dic_sync_info_service(server+'/SERVICE_LIST','C',timeout=3)[0] + if sl_raw == None: + print "couldn't get the service list of ", server, "program abortion..." + sys.exit(1) +# print server +# print sl_raw + # even without parsing, I can find out, if this server also gives me a + # service description list. In case it does not, this is fine as well + # the doc string of the dynamicly created methods, will then contain + # a note, that therer was no SERVICE_DESC ... + if server+'/SERVICE_DESC' in sl_raw: + sd_raw = pydim.dic_sync_info_service(server+'/SERVICE_DESC','C',timeout=3)[0] + if sd_raw == None: + print "couldn't get the service description list of ", server, "program abortion..." + sys.exit(1) + else: + sd_raw = '' + + # now before parsing, I strip off all ASCII zeroes '\x00' and all + # line breaks off the *end* of the long string of both + # the service list sl + # and service description sd + # + # I think in sl_raw were alse some '\x00' in the middle .. these + # are replaced by nothing, in case they are there. + sl_raw = sl_raw.rstrip('\x00\n') + sl_raw = sl_raw.replace('\x00','') + sd_raw = sd_raw.rstrip('\x00\n') + + # The lists are seperated by line breaks, so I split them using this + sl = sl_raw.split('\n') + sd = sd_raw.split('\n') + + # First I parse the service descriptons, so I have them available, + # when I create the dict full of services. + # All desciptions look like this + # 'SERVER/SERVICE=some descriptive text' or + # 'SERVER/SERVICE=' + # this I use to create the dictionary. + # create descripton dict dd from service_desc list sd + for d_str in sd: + service,equalsign,desc = d_str.partition('=') + if not '/' in service: + service = server+'/'+service + #if '=' != equalsign: + # print "Error: server:", server, "desc:", d_str + dd[service] = desc + + # Now I fill ther services dict. Each server gets a nested dict + # inside services. + # Each service is explained in a string with a '|' in between. + # I use this for spliting. + # The string look like this + # SERVER/SERVICE|format-desc-str(e.g. I:2;C)|-empty- or CMD or RPC| + services[server] = {} + for service in sl: + service = service.split('|') + if service[0] in dd: + services[server][service[0]] = ( + service[1], service[2], dd[service[0]]) + return services, dd + + + +if __name__ == '__main__': + + print 'requesting and parsing DIM DNS server list' + servers = ParseDnsServerList() + print '... parsing each servers service list' + services, dd = ParseServersServiceList( servers ) + + # since I want this text to created for reference + # I will create it here + print "creating fix class definitions in a file:" + f = open("fact_dim_servers.py", "w") + f.write("from make_fix_dimservers import FactDimServer\n") + + for server_name in servers: + + if server_name == "DIS_DNS": + continue + + f.write("class "+server_name+" ( FactDimServer): \n") + + for cmd in services[server_name]: + cmdname = cmd.split('/') + if len(cmdname) > 1: + cmdname = cmdname[1] + elif len(cmdname) >0: + cmdname = cmdname[0] + cmd = server_name+'/'+cmdname + else: + print server_name, cmd + raise ValueError('was not able to parse service/command names') + if 'CMD' in services[server_name][cmd][1]: + print_command(cmd, f) + elif not services[server_name][cmd][1]: + print_getter(cmd, f) + + + f.close() + + import fact_dim_servers + + # create an instace of each of the classes + # and make it globally known, i.e. known to the Python interpreter + # all the ServerClass instances are collected in a list + # so one can get a quick overview --> print dims + print 'creating an instance of each FACT DIM server' + + dims = [] + new_instance = None + for server_name in servers: + if server_name == 'DIS_DNS': + continue + new_instance = getattr(sys.modules["fact_dim_servers"], server_name)(server_name, services) + dims.append( new_instance ) + globals()[server_name.lower()] = new_instance + del new_instance + + print '.... fact DIM servers are ready to use' + print '-'*70 + print +