{ *************************************************************************** } MODULE mod_handle_sptrg ; { Created 11-MAY-1989 MICHIGAN STATE UNIVERSITY, TRIGGER CONTROL SOFTWARE } { *************************************************************************** } INCLUDE mod_common_global_flags, mod_def_hardware_tables, mod_def_physics_tables, mod_handle_tracing, mod_handle_registers, mod_handle_scalers, mod_common_hard_io ; {from the TRICS hardware IO library } { *************************************************************************** } EXPORT enable_global, {PROCEDURE globally enable/disable specific trigger } enable_obeybz, {PROCEDURE enable/disable to obey front end busy signal } enable_obeyl2, {PROCEDURE enable/disable to obey level 2 disable signal } enable_obeybeam,{PROCEDURE enable/disable to obey beam qualityr signal } enable_autodis, {PROCEDURE enable/disable to be i autodisable mode } reenab_sptrg, {PROCEDURE reset the autodisable flip-flop } prog_aoterm, {PROCEDURE modify single andor input term for a spec trig } prog_startdgt, {PROCEDURE modify single geo sec to be digitized by a sptrg} prog_watchbusy, {PROCEDURE modify single geo sec to try to disable a sptrg} prog_prescaler, {PROCEDURE enable/disable prescaler and write prescale ratio} reset_sptrg_aofired_scaler, {PROCEDURE reset spec trig andor fired scaler } reset_sptrg_fired_scaler, {PROCEDURE reset spec trig fired scaler } reset_sptrg_exposed_scaler, {PROCEDURE reset spec trig exposition scaler } reset_sptrg_veto_scalers, {PROCEDURE reset spec trig all veto scalers } reset_sptrg_l15_scalers, {PROCEDURE reset spec trig Level 1.5 scalers } load_rdtime, {PROCEDURE laod spec trig readout time } autotune_sptrg, {PROCEDURE watch andor firing and pick presc rat} setup_force_db, {PROCEDURE setup spec trig to force a dblock } force_datablock,{PROCEDURE reenable the specialized sptrg to force a dblock } level15_type, {PROCEDURE setup spec trig to need a Level 1.5 confirmation } prog_l15confirm,{PROCEDURE setup spec trig to require a given Level 1.5 term} show_sptrg ; {PROCEDURE show a specific trigger physics programming } { *************************************************************************** } IMPORT status_type, ok, already_done, io_failure, wrong_mode, not_found, {from module MOD_COMMON_GLOBAL_FLAGS } trace_info, trace_warn, trace_error,{from module MOD_HANDLE_TRACING } inline_tracing, {from module MOD_HANDLE_TRACING } handle_trc_inf, {from module MOD_HANDLE_TRACING } handle_trc_wrn, {from module MOD_HANDLE_TRACING } handle_trc_err, {from module MOD_HANDLE_TRACING } aoterm_per_aobackp, it_0_127, it_128_255, sptrg_per_fstd, {st_0_3, st_4_7, st_8_11, st_12_15, st_16_19, st_20_23, st_24_27, st_28_31,} sptrg_number, {st_0, st_1, st_2, st_3, st_4, st_5, st_6, st_7, st_8, st_9, st_10, st_11, st_12, st_13, st_14, st_15, st_16, st_17, st_18, st_19, st_20, st_21, st_22, st_23, st_24, st_25, st_26, st_27, st_28, st_29, st_30, st_31,} sptrg_per_dbsc, {st_0_1, st_2_3, st_4_5, st_6_7, st_8_9, st_10_11, st_12_13, st_14_15, st_16_17, st_18_19, st_20_21, st_22_23, st_24_25, st_26_27, st_28_29, st_30_31,} geosec_per_digm, {gs_0_3, gs_4_7, gs_8_11, gs_12_15, gs_16_19, gs_20_23, gs_24_27, gs_28_31,} sptrg_per_digm, {geosec_per_tlm, gs_0_7, gs_8_15, gs_16_23, gs_24_31,} {fired_cable_per_tlm, fc_0_3, fc_4_7, {scaler_per_dbsc,} exposc, firedsc, relative_sptrg, {relst_0, relst_1, relst_2, relst_3,} relative_geo_section,{relgs_0, relgs_1, relgs_2, relgs_3,} {from module MOD_DEF_HARDWARE_TABLES } {bbb, mbd, imlinput, imlroinput,}andor, fstd, dbsc, sbscdis, sbscaofired, {tlmfired, imlrofired,}dgmstdig,{tlmbusy, imlrobusy,}dgmbzdis,{tlmtrgnum, tlmstdig, tlmfiredstb, tlmfiredout, imlroaux, mtgaux, mtgholdtx, mtgstdig, mtgbusy, mtgtss, dbsctrgnum,} dgmL15_ans, {from module MOD_DEF_HARDWARE_TABLES } dgmL15_ctrl, {from module MOD_DEF_HARDWARE_TABLES } mtgL15_vc, {from module MOD_DEF_HARDWARE_TABLES } mtgL15_mux, {from module MOD_DEF_HARDWARE_TABLES } sbscL15_cnf_rej, {from module MOD_DEF_HARDWARE_TABLES } sbscL15_cyc_skp, {from module MOD_DEF_HARDWARE_TABLES } sbscL15_dead_to, {from module MOD_DEF_HARDWARE_TABLES } tss_l15_veto_enb, {from module MOD_DEF_HARDWARE_TABLES } tss_l15_veto_low, {from module MOD_DEF_HARDWARE_TABLES } tss_l15_confirm_enb, {from module MOD_DEF_HARDWARE_TABLES } tss_l15_confirm_low, {from module MOD_DEF_HARDWARE_TABLES } tss_l15_receive_enb, {from module MOD_DEF_HARDWARE_TABLES } {possible_allocation,} {from module MOD_DEF_PHYSICS_TABLES } all_none, all_coor,{all_phat, all_redundancy,}all_forcedb, force_db_sptrg, {from module MOD_DEF_PHYSICS_TABLES } force_db_mode, {from module MOD_DEF_PHYSICS_TABLES } {obey_ignore,}ignore, obey, {from module MOD_DEF_PHYSICS_TABLES } sptrg, {from module MOD_DEF_PHYSICS_TABLES } set_of_sptrg, {from module MOD_DEF_PHYSICS_TABLES } targ_acqbandw, {from module MOD_DEF_PHYSICS_TABLES } update_register, {from module MOD_HANDLE_REGISTERS } update_prscratio, {from module MOD_HANDLE_REGISTERS } {load_sbscalers,} {from module MOD_HANDLE_SCALERS } reset_dbscaler, {from module MOD_HANDLE_SCALERS } reset_sbscaler, {from module MOD_HANDLE_SCALERS } read_sbscalers, {from module MOD_HANDLE_SCALERS } read_dbscaler, {from module MOD_HANDLE_SCALERS } cbus_param_list ; {from module MOD_COMMON_HARD_IO } { *************************************************************************** } { *************************************************************************** } %INCLUDE 'SITE_DEPENDENT.CST/LIST' TYPE bit = [BIT(1)] 0..1 ; byte = [BYTE] 0..255 ; byte_by_bit = [BYTE] PACKED RECORD bit0 : [POS(0)] bit ; bit1 : [POS(1)] bit ; bit2 : [POS(2)] bit ; bit3 : [POS(3)] bit ; bit4 : [POS(4)] bit ; bit5 : [POS(5)] bit ; bit6 : [POS(6)] bit ; bit7 : [POS(7)] bit ; END ; VAR tag : VARYING_STRING(8) := 'HST/ODB%' ; { *************************************************************************** } { *************************************************************************** } PROCEDURE enable_global ( tagext : VARYING_STRING(8) := '' ; sptrgnum : INTEGER ; enable : BOOLEAN ; iopar :^cbus_param_list ; VAR status : [OPTIONAL] status_type ) ; VAR fd_st : sptrg_per_fstd ; relst : relative_sptrg ; io_status : status_type ; BEGIN IF PRESENT(status) THEN status := ok ; sptrg[sptrgnum]^.status.initialized := FALSE ; { *** check on the previous state } IF ( enable = TRUE ) THEN BEGIN IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Setting Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Globally Enabled' ) ; IF ( sptrg[sptrgnum]^.enable.globaldis = ignore ) THEN BEGIN IF PRESENT(status) THEN status := already_done ; IF ( inline_tracing(trace_warn) <> 0 ) THEN handle_trc_wrn ( TAG := tag + tagext, MESSAGE := ' Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Already Enabled' ) ; END ; END ELSE BEGIN IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Setting Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Globally Disabled ' ) ; IF ( sptrg[sptrgnum]^.enable.globaldis = obey ) THEN BEGIN IF PRESENT(status) THEN status := already_done ; IF ( inline_tracing(trace_warn) <> 0 ) THEN handle_trc_wrn ( TAG := tag + tagext, MESSAGE := ' Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Already Disabled' ) ; END ; END ; { *** modify the physics data base } IF ( enable = TRUE ) THEN sptrg[sptrgnum]^.enable.globaldis := ignore { enable sptrg } ELSE sptrg[sptrgnum]^.enable.globaldis := obey ; { disable sptrg } { *** compute the correct fstd cards relative number } fd_st := CONVERT(sptrg_per_fstd,sptrgnum DIV 4) ; relst := CONVERT(relative_sptrg,sptrgnum MOD 4) ; { *** modify the hardware data base } update_register ( TAGEXT := tagext, CARD := ADDRESS(fstd[fd_st]), REGISTER := ADDRESS(fstd[fd_st].enabreg[relst]), IOPAR := iopar, DATA := sptrg[sptrgnum]^.enable::BYTE , STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Global Enable Bit' ) ; IF PRESENT(status) THEN status := io_status ; END ; END ; { *************************************************************************** } { *************************************************************************** } PROCEDURE enable_obeybz ( tagext : VARYING_STRING(8) := '' ; sptrgnum : INTEGER ; obeybz : BOOLEAN ; iopar :^cbus_param_list ; VAR status : [OPTIONAL] status_type ) ; VAR fd_st : sptrg_per_fstd ; relst : relative_sptrg ; io_status : status_type ; BEGIN IF PRESENT(status) THEN status := ok ; sptrg[sptrgnum]^.status.initialized := FALSE ; { *** check on the previous state } IF ( obeybz = TRUE ) THEN BEGIN IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Setting Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' to Obey F-end Busy ') ; IF ( sptrg[sptrgnum]^.enable.fendbz = obey ) THEN BEGIN IF PRESENT(status) THEN status := already_done ; IF ( inline_tracing(trace_warn) <> 0 ) THEN handle_trc_wrn ( TAG := tag + tagext, MESSAGE := ' Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Already Obeying Front-end Busy' ) ; END ; END ELSE BEGIN IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Setting Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' to Ignore F-end Busy '); IF ( sptrg[sptrgnum]^.enable.fendbz = ignore ) THEN BEGIN IF PRESENT(status) THEN status := already_done ; IF ( inline_tracing(trace_warn) <> 0 ) THEN handle_trc_wrn ( TAG := tag + tagext, MESSAGE := ' Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Already Ignoring Front-end Busy' ) ; END ; END ; { *** modify the physics data base } IF ( obeybz = TRUE ) THEN sptrg[sptrgnum]^.enable.fendbz := obey ELSE sptrg[sptrgnum]^.enable.fendbz := ignore ; { *** compute the correct fstd cards relative number } fd_st := CONVERT(sptrg_per_fstd,sptrgnum DIV 4) ; relst := CONVERT(relative_sptrg,sptrgnum MOD 4) ; { *** modify the hardware data base } update_register ( TAGEXT := tagext, CARD := ADDRESS(fstd[fd_st]), REGISTER := ADDRESS(fstd[fd_st].enabreg[relst]), IOPAR := iopar, DATA := sptrg[sptrgnum]^.enable::BYTE , STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' F-enf Busy Obey Bit' ) ; IF PRESENT(status) THEN status := io_status ; END ; END ; { *************************************************************************** } { *************************************************************************** } PROCEDURE enable_obeyl2 ( tagext : VARYING_STRING(8) := '' ; sptrgnum : INTEGER ; obeyl2 : BOOLEAN ; iopar :^cbus_param_list ; VAR status : [OPTIONAL] status_type ) ; VAR fd_st : sptrg_per_fstd ; relst : relative_sptrg ; io_status : status_type ; BEGIN IF PRESENT(status) THEN status := ok ; sptrg[sptrgnum]^.status.initialized := FALSE ; { *** check on the previous state } IF ( obeyl2 = TRUE ) THEN BEGIN IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Setting Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' to Obey Level 2 ') ; IF ( sptrg[sptrgnum]^.enable.level2 = obey ) THEN BEGIN IF PRESENT(status) THEN status := already_done ; IF ( inline_tracing(trace_warn) <> 0 ) THEN handle_trc_wrn ( TAG := tag + tagext, MESSAGE := ' Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Already Obeying Level 2 ' ) ; END ; END ELSE BEGIN IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Setting Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' to Ignore Level 2 '); IF ( sptrg[sptrgnum]^.enable.level2 = ignore ) THEN BEGIN IF PRESENT(status) THEN status := already_done ; IF ( inline_tracing(trace_warn) <> 0 ) THEN handle_trc_wrn ( TAG := tag + tagext, MESSAGE := ' Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Already Ignoring Level 2 ' ) ; END ; END ; { *** modify the physics data base } IF ( obeyl2 = TRUE ) THEN sptrg[sptrgnum]^.enable.level2 := obey ELSE sptrg[sptrgnum]^.enable.level2 := ignore ; { *** compute the correct fstd cards relative number } fd_st := CONVERT(sptrg_per_fstd,sptrgnum DIV 4) ; relst := CONVERT(relative_sptrg,sptrgnum MOD 4) ; { *** modify the hardware data base } update_register ( TAGEXT := tagext, CARD := ADDRESS(fstd[fd_st]), REGISTER := ADDRESS(fstd[fd_st].enabreg[relst]), IOPAR := iopar, DATA := sptrg[sptrgnum]^.enable::BYTE , STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Level 2 Obey Bit' ) ; IF PRESENT(status) THEN status := io_status ; END ; END ; { *************************************************************************** } { *************************************************************************** } PROCEDURE enable_obeybeam ( tagext : VARYING_STRING(8) := '' ; sptrgnum : INTEGER ; obeybeam : BOOLEAN ; iopar :^cbus_param_list ; VAR status : [OPTIONAL] status_type ) ; VAR fd_st : sptrg_per_fstd ; relst : relative_sptrg ; io_status : status_type ; BEGIN IF PRESENT(status) THEN status := ok ; sptrg[sptrgnum]^.status.initialized := FALSE ; { *** check on the previous state } IF ( obeybeam = TRUE ) THEN BEGIN IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Setting Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' to Obey Beam Quality Veto ') ; IF ( sptrg[sptrgnum]^.enable.beam = obey ) THEN BEGIN IF PRESENT(status) THEN status := already_done ; IF ( inline_tracing(trace_warn) <> 0 ) THEN handle_trc_wrn ( TAG := tag + tagext, MESSAGE := ' Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Already Obeying Beam Quality Veto ' ) ; END ; END ELSE BEGIN IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Setting Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' to Ignore Beam Quality Veto '); IF ( sptrg[sptrgnum]^.enable.beam = ignore ) THEN BEGIN IF PRESENT(status) THEN status := already_done ; IF ( inline_tracing(trace_warn) <> 0 ) THEN handle_trc_wrn ( TAG := tag + tagext, MESSAGE := ' Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Already Ignoring Beam Quality Veto ' ) ; END ; END ; { *** modify the physics data base } IF ( obeybeam = TRUE ) THEN sptrg[sptrgnum]^.enable.beam := obey ELSE sptrg[sptrgnum]^.enable.beam := ignore ; { *** compute the correct fstd cards relative number } fd_st := CONVERT(sptrg_per_fstd,sptrgnum DIV 4) ; relst := CONVERT(relative_sptrg,sptrgnum MOD 4) ; { *** modify the hardware data base } update_register ( TAGEXT := tagext, CARD := ADDRESS(fstd[fd_st]), REGISTER := ADDRESS(fstd[fd_st].enabreg[relst]), IOPAR := iopar, DATA := sptrg[sptrgnum]^.enable::BYTE , STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Beam Quality Obey Bit' ) ; IF PRESENT(status) THEN status := io_status ; END ; END ; { *************************************************************************** } { *************************************************************************** } PROCEDURE enable_autodis ( tagext : VARYING_STRING(8) := '' ; sptrgnum : INTEGER ; autodis : BOOLEAN ; iopar :^cbus_param_list ; VAR status : [OPTIONAL] status_type ) ; VAR fd_st : sptrg_per_fstd ; relst : relative_sptrg ; io_status : status_type ; BEGIN IF PRESENT(status) THEN status := ok ; sptrg[sptrgnum]^.status.initialized := FALSE ; { *** check on the previous state } IF ( autodis = TRUE ) THEN BEGIN IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Setting Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Autodisable Mode' ) ; IF ( sptrg[sptrgnum]^.enable.autodis = obey ) THEN BEGIN IF PRESENT(status) THEN status := already_done ; IF ( inline_tracing(trace_warn) <> 0 ) THEN handle_trc_wrn ( TAG := tag + tagext, MESSAGE := ' Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Already in Autodisable Mode ' ) ; END ; END ELSE BEGIN IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Setting Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Not Autodisabled ' ) ; IF ( sptrg[sptrgnum]^.enable.autodis = ignore ) THEN BEGIN IF PRESENT(status) THEN status := already_done ; IF ( inline_tracing(trace_warn) <> 0 ) THEN handle_trc_wrn ( TAG := tag + tagext, MESSAGE := ' Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Already Not in Autodisable Mode ' ) ; END ; END ; { *** modify the physics data base } IF ( autodis = TRUE ) THEN sptrg[sptrgnum]^.enable.autodis := obey ELSE sptrg[sptrgnum]^.enable.autodis := ignore ; { *** compute the correct fstd cards relative number } fd_st := CONVERT(sptrg_per_fstd,sptrgnum DIV 4) ; relst := CONVERT(relative_sptrg,sptrgnum MOD 4) ; { *** modify the hardware data base } update_register ( TAGEXT := tagext, CARD := ADDRESS(fstd[fd_st]), REGISTER := ADDRESS(fstd[fd_st].enabreg[relst]), IOPAR := iopar, DATA := sptrg[sptrgnum]^.enable::BYTE , STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Autodisable Bit' ) ; IF PRESENT(status) THEN status := io_status ; END ; END ; { *************************************************************************** } { *************************************************************************** } PROCEDURE reenab_sptrg ( tagext : VARYING_STRING(8) := '' ; sptrgnum : INTEGER ; iopar :^cbus_param_list ; VAR status : [OPTIONAL] status_type ) ; VAR fd_st : sptrg_per_fstd ; relst : relative_sptrg ; io_status : status_type ; BEGIN IF PRESENT(status) THEN status := ok ; sptrg[sptrgnum]^.status.initialized := FALSE ; { *** check on the autodisable mode } IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Setting Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Reenabled ' ) ; IF ( sptrg[sptrgnum]^.enable.autodis <> obey ) THEN BEGIN IF PRESENT(status) THEN status := wrong_mode ; IF ( inline_tracing(trace_warn) <> 0 ) THEN handle_trc_wrn ( TAG := tag + tagext, MESSAGE := ' Spec Trigger #' + cONVERT(STRING,sptrgnum) + ' is Not in Autodisable Mode' ) ; END ; { *** compute the correct fstd cards relative number } fd_st := CONVERT(sptrg_per_fstd,sptrgnum DIV 4) ; relst := CONVERT(relative_sptrg,sptrgnum MOD 4) ; { *** set reenable bit high } sptrg[sptrgnum]^.enable.reenable := obey ; update_register ( TAGEXT := tagext, CARD := ADDRESS(fstd[fd_st]), REGISTER := ADDRESS(fstd[fd_st].enabreg[relst]), IOPAR := iopar, DATA := sptrg[sptrgnum]^.enable::BYTE , STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Reenable Bit' ) ; IF PRESENT(status) THEN status := io_status ; END ; { *** reset reenable bit low } sptrg[sptrgnum]^.enable.reenable := ignore ; update_register ( TAGEXT := tagext, CARD := ADDRESS(fstd[fd_st]), REGISTER := ADDRESS(fstd[fd_st].enabreg[relst]), IOPAR := iopar, DATA := sptrg[sptrgnum]^.enable::BYTE , STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Reenable Bit' ) ; IF PRESENT(status) THEN status := io_status ; END ; END ; { *************************************************************************** } { *************************************************************************** } PROCEDURE prog_prescaler ( tagext : VARYING_STRING(8) := '' ; sptrgnum : INTEGER ; prescale : BOOLEAN ; ratio : INTEGER ; iopar :^cbus_param_list ; VAR status :[OPTIONAL] status_type ) ; VAR fd_st : sptrg_per_fstd ; relst : relative_sptrg ; io_status : status_type ; BEGIN IF PRESENT(status) THEN status := ok ; sptrg[sptrgnum]^.status.initialized := FALSE ; { *** check on the previous state } IF ( prescale = FALSE ) THEN BEGIN IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Setting Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Not Prescaled' ) ; IF ( sptrg[sptrgnum]^.enable.prsc = ignore ) THEN BEGIN IF PRESENT(status) THEN status := already_done ; IF ( inline_tracing(trace_warn) <> 0 ) THEN handle_trc_wrn ( TAG := tag + tagext, MESSAGE := ' Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Prescaler Already Disabled' ) ; END ; END ELSE BEGIN IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Setting Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Prescaled by ' + CONVERT(STRING,ratio) ); IF ( ( sptrg[sptrgnum]^.enable.prsc = obey ) AND ( sptrg[sptrgnum]^.prscratio = ratio ) ) THEN BEGIN IF PRESENT(status) THEN status := already_done ; IF ( inline_tracing(trace_warn) <> 0 ) THEN handle_trc_wrn ( TAG := tag + tagext, MESSAGE := ' Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Already Prescaled by ' + CONVERT(STRING,ratio) ); END ; END ; { *** modify the physics data base } IF ( prescale = TRUE ) THEN BEGIN sptrg[sptrgnum]^.enable.prsc := obey ; { enable prescaler } sptrg[sptrgnum]^.prscratio := ratio ; END ELSE BEGIN sptrg[sptrgnum]^.enable.prsc := ignore ; { disable prescaler } sptrg[sptrgnum]^.prscratio := 1 ; END ; { *** compute the correct fstd cards relative number } fd_st := CONVERT ( sptrg_per_fstd, sptrgnum DIV 4 ) ; relst := CONVERT ( relative_sptrg, sptrgnum MOD 4 ) ; { *** modify the prescaler ratio } update_prscratio ( TAGEXT := tagext, CARD := ADDRESS(fstd[fd_st]), REGISTER := ADDRESS(fstd[fd_st].psctrlreg[relst]), IOPAR := iopar, RATIO := sptrg[sptrgnum]^.prscratio, STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Prescaler Ratio' ) ; IF PRESENT(status) THEN status := io_status ; END ; { *** modify the hardware data base } update_register ( TAGEXT := tagext, CARD := ADDRESS(fstd[fd_st]), REGISTER := ADDRESS(fstd[fd_st].enabreg[relst]), IOPAR := iopar, DATA := sptrg[sptrgnum]^.enable::BYTE , STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Prescaler Bit' ) ; IF PRESENT(status) THEN status := io_status ; END ; END ; { *************************************************************************** } { *************************************************************************** } PROCEDURE prog_startdgt ( tagext : VARYING_STRING(8) := '' ; sptrgnum : INTEGER ; geosecnum : INTEGER ; digitize : BOOLEAN := TRUE ; iopar :^cbus_param_list ; VAR status : [OPTIONAL] status_type ); VAR gs_sd : geosec_per_digm ; relgs : relative_geo_section ; io_status : status_type ; basesptrg : 0..28 ; basereg : 0..7 ; data : byte_by_bit ; BEGIN IF PRESENT(status) THEN status := ok ; sptrg[sptrgnum]^.status.initialized := FALSE ; { *** check on the previous state } IF ( digitize = TRUE ) THEN BEGIN IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Setting Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Start Digt Geo Sec #' + CONVERT(STRING,geosecnum) ) ; IF ( sptrg[sptrgnum]^.geosec[geosecnum].digitize = 1 ) THEN BEGIN IF PRESENT(status) THEN status := already_done ; IF ( inline_tracing(trace_warn) <> 0 ) THEN handle_trc_wrn ( TAG := tag + tagext, MESSAGE := ' Spec Trig #' + CONVERT(STRING,sptrgnum) + ' Already Digitizing Geo Section #' + CONVERT(STRING,geosecnum) ) ; END ; END ; { *** modify the physics data base } IF ( digitize = TRUE ) THEN sptrg[sptrgnum]^.geosec[geosecnum].digitize := 1 ELSE sptrg[sptrgnum]^.geosec[geosecnum].digitize := 0 ; { *** compute the correct digimem card indices } gs_sd := CONVERT ( geosec_per_digm, geosecnum DIV 4 ) ; relgs := CONVERT ( relative_geo_section, geosecnum MOD 4 ) ; basereg := sptrgnum DIV 4 ; basesptrg := sptrgnum - ( sptrgnum MOD 4 ) ; { *** compute the data to send to the digimem card } data::BYTE := 15 ; { all bits required low when included } data.bit4 := 1 - sptrg[basesptrg+0]^.geosec[geosecnum].digitize;{a bit is } data.bit5 := 1 - sptrg[basesptrg+1]^.geosec[geosecnum].digitize;{required if} data.bit6 := 1 - sptrg[basesptrg+2]^.geosec[geosecnum].digitize;{a geosec is} data.bit7 := 1 - sptrg[basesptrg+3]^.geosec[geosecnum].digitize;{digitized } { *** modify the hardware data base } update_register ( TAGEXT := tagext, CARD := ADDRESS(dgmstdig[gs_sd]), REGISTER := ADDRESS(dgmstdig[gs_sd].netreg[relgs,basereg]), IOPAR := iopar, DATA := data::BYTE, STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Digitizing of Geo Sec#' + CONVERT(STRING,geosecnum) ) ; IF PRESENT(status) THEN status := io_status ; END ; END ; { *************************************************************************** } { *************************************************************************** } PROCEDURE prog_watchbusy ( tagext : VARYING_STRING(8) := '' ; sptrgnum : INTEGER ; geosecnum : INTEGER ; watchbz : BOOLEAN := TRUE ; iopar :^cbus_param_list ; VAR status : [OPTIONAL] status_type ); VAR st_dg : sptrg_per_digm ; relst : relative_sptrg ; io_status : status_type ; basegeosec : 0..28 ; basereg : 0..7 ; data : byte_by_bit ; BEGIN IF PRESENT(status) THEN status := ok ; sptrg[sptrgnum]^.status.initialized := FALSE ; { *** check on the previous state } IF ( watchbz = TRUE ) THEN BEGIN IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Setting Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Disabled by Geo Sec #' + CONVERT(STRING,geosecnum) ) ; IF ( sptrg[sptrgnum]^.geosec[geosecnum].watchbz = 1 ) THEN BEGIN IF PRESENT(status) THEN status := already_done ; IF ( inline_tracing(trace_warn) <> 0 ) THEN handle_trc_wrn ( TAG := tag + tagext, MESSAGE := ' Spec Trig #' + CONVERT(STRING,sptrgnum) + ' Already Disabled by Geo Section #' + CONVERT(STRING,geosecnum) ) ; END ; END ; { *** modify the physics data base } IF ( watchbz = TRUE ) THEN sptrg[sptrgnum]^.geosec[geosecnum].watchbz := 1 ELSE sptrg[sptrgnum]^.geosec[geosecnum].watchbz := 0 ; { *** compute the correct digimem card indices } st_dg := CONVERT ( sptrg_per_digm, sptrgnum DIV 4 ) ; relst := CONVERT ( relative_sptrg, sptrgnum MOD 4 ) ; basereg := geosecnum DIV 4 ; basegeosec := geosecnum - ( geosecnum MOD 4 ) ; { *** compute the data to send to the digimem card } data::BYTE := 15 ; { all bits required low when included } data.bit4 := 1 - sptrg[sptrgnum]^.geosec[basegeosec+0].watchbz; {a bit is } data.bit5 := 1 - sptrg[sptrgnum]^.geosec[basegeosec+1].watchbz; {required if} data.bit6 := 1 - sptrg[sptrgnum]^.geosec[basegeosec+2].watchbz; {a geosec is} data.bit7 := 1 - sptrg[sptrgnum]^.geosec[basegeosec+3].watchbz; {digitized } { *** modify the hardware data base } update_register ( TAGEXT := tagext, CARD := ADDRESS(dgmbzdis[st_dg]), REGISTER := ADDRESS(dgmbzdis[st_dg].netreg[relst,basereg]), IOPAR := iopar, DATA := data::BYTE, STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Disabling by Geo Sec#' + CONVERT(STRING,geosecnum) ) ; IF PRESENT(status) THEN status := io_status ; END ; END ; { *************************************************************************** } { *************************************************************************** } PROCEDURE prog_aoterm ( tagext : VARYING_STRING(8) := '' ; sptrgnum : INTEGER ; aotermnum : INTEGER ; excluded : BOOLEAN := FALSE ; polarity : BOOLEAN := TRUE ; iopar :^cbus_param_list ; VAR status : [OPTIONAL] status_type ); TYPE high_low = (low, high) ; VAR st_ao : sptrg_number ; ao_bp : aoterm_per_aobackp ; io_status : status_type ; baseaoterm : 0..252 ; basereg : 0..31 ; data : byte_by_bit ; dupolar : [BYTE] high_low ; BEGIN IF PRESENT(status) THEN status := ok ; sptrg[sptrgnum]^.status.initialized := FALSE ; dupolar::BYTE_DATA := polarity::BYTE_DATA ; { *** check on the previous state } IF ( excluded = FALSE ) THEN IF ( inline_tracing(trace_info) <> 0 ) THEN BEGIN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Setting Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' to Require Andor Term #' + CONVERT(STRING,aotermnum) + ' to be ' + CONVERT(STRING,dupolar) ) ; END ; IF ( sptrg[sptrgnum]^.aoterm[aotermnum].excluded = 0 ) THEN IF ( ( ( polarity = TRUE ) AND ( sptrg[sptrgnum]^.aoterm[aotermnum].polarity = 1 ) ) OR ( ( polarity = FALSE ) AND ( sptrg[sptrgnum]^.aoterm[aotermnum].polarity = 0 ) ) ) THEN BEGIN IF PRESENT(status) THEN status := already_done ; IF ( inline_tracing(trace_warn) <> 0 ) THEN handle_trc_wrn ( TAG := tag + tagext, MESSAGE := ' Spec Trg #' + CONVERT(STRING,sptrgnum) + ' Already Requiring Andor Term #' + CONVERT(STRING,aotermnum) + ' to be ' + CONVERT(STRING,dupolar) ) ; END ; { *** modify the physics data base } IF ( excluded = TRUE ) THEN sptrg[sptrgnum]^.aoterm[aotermnum].excluded := 1 {andor term excluded} ELSE sptrg[sptrgnum]^.aoterm[aotermnum].excluded := 0 ; {andor term included} IF ( polarity = TRUE ) THEN sptrg[sptrgnum]^.aoterm[aotermnum].polarity := 1 {required high } ELSE sptrg[sptrgnum]^.aoterm[aotermnum].polarity := 0 ; {required low } { *** compute the correct andor card indices } IF ( aotermnum < 128 ) THEN ao_bp := it_0_127 ELSE ao_bp := it_128_255 ; st_ao := CONVERT(sptrg_number,sptrgnum) ; basereg := ( aotermnum MOD 128 ) DIV 4 ; baseaoterm := aotermnum - ( aotermnum MOD 4 ) ; { *** compute the data to send to the andor card } data.bit0 := 1 - sptrg[sptrgnum]^.aoterm[baseaoterm+0].polarity ; data.bit1 := 1 - sptrg[sptrgnum]^.aoterm[baseaoterm+1].polarity ; data.bit2 := 1 - sptrg[sptrgnum]^.aoterm[baseaoterm+2].polarity ; data.bit3 := 1 - sptrg[sptrgnum]^.aoterm[baseaoterm+3].polarity ; data.bit4 := sptrg[sptrgnum]^.aoterm[baseaoterm+0].excluded ; data.bit5 := sptrg[sptrgnum]^.aoterm[baseaoterm+1].excluded ; data.bit6 := sptrg[sptrgnum]^.aoterm[baseaoterm+2].excluded ; data.bit7 := sptrg[sptrgnum]^.aoterm[baseaoterm+3].excluded ; { *** modify the hardware data base } update_register ( TAGEXT := tagext, CARD := ADDRESS(andor[ao_bp,st_ao]), REGISTER := ADDRESS(andor[ao_bp,st_ao].netreg[basereg]), IOPAR := iopar, DATA := data::BYTE, STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Andor Input Term #' + CONVERT(STRING,aotermnum) ) ; IF PRESENT(status) THEN status := io_status ; END ; END ; { *************************************************************************** } { *************************************************************************** } PROCEDURE reset_sptrg_aofired_scaler ( tagext : VARYING_STRING(8) := '' ; sptrgnum : INTEGER ; iopar :^cbus_param_list ; VAR status : [OPTIONAL] status_type ); VAR scaler : INTEGER ; io_status : status_type ; BEGIN IF PRESENT(status) THEN status := ok ; { *** compute the correct sbsc relative scaler } scaler := sptrgnum ; { *** reset scaler } reset_sbscaler ( TAGEXT := tagext, CARD := ADDRESS(sbscaofired), REGISTER := ADDRESS(sbscaofired.datareg), IOPAR := iopar, SCALER := scaler, STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Reset AO Fired Scaler' ) ; IF PRESENT(status) THEN status := io_status ; END ; END ; { *************************************************************************** } { *************************************************************************** } PROCEDURE reset_sptrg_fired_scaler ( tagext : VARYING_STRING(8) := '' ; sptrgnum : INTEGER ; check_reset : BOOLEAN := TRUE ; iopar :^cbus_param_list ; VAR status : [OPTIONAL] status_type ); VAR st_ds : sptrg_per_dbsc ; relst : relative_sptrg ; io_status : status_type ; BEGIN IF PRESENT(status) THEN status := ok ; { *** compute the correct dbsc relative scaler } st_ds := CONVERT(sptrg_per_dbsc,sptrgnum DIV 2) ; relst := CONVERT(relative_sptrg,sptrgnum MOD 2) ; { *** reset scaler } reset_dbscaler ( TAGEXT := tagext, CARD := ADDRESS(dbsc[st_ds]), REGISTER := ADDRESS(dbsc[st_ds].resetreg[relst,firedsc]), CHECK_RESET := check_reset, IOPAR := iopar, STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Reset Sptrg Fir Scaler' ) ; IF PRESENT(status) THEN status := io_status ; END ; END ; { *************************************************************************** } { *************************************************************************** } PROCEDURE reset_sptrg_exposed_scaler ( tagext : VARYING_STRING(8) := '' ; sptrgnum : INTEGER ; check_reset : BOOLEAN := TRUE ; iopar :^cbus_param_list ; VAR status : [OPTIONAL] status_type ); VAR st_ds : sptrg_per_dbsc ; relst : relative_sptrg ; io_status : status_type ; BEGIN IF PRESENT(status) THEN status := ok ; { *** compute the correct dbsc relative scaler } st_ds := CONVERT(sptrg_per_dbsc,sptrgnum DIV 2) ; relst := CONVERT(relative_sptrg,sptrgnum MOD 2) ; { *** reset scaler } reset_dbscaler ( TAGEXT := tagext, CARD := ADDRESS(dbsc[st_ds]), REGISTER := ADDRESS(dbsc[st_ds].resetreg[relst,exposc]), CHECK_RESET := check_reset, IOPAR := iopar, STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Reset Sptrg Expo Scaler' ) ; IF PRESENT(status) THEN status := io_status ; END ; END ; { *************************************************************************** } { *************************************************************************** } PROCEDURE reset_sptrg_veto_scalers ( tagext : VARYING_STRING(8) := '' ; sptrgnum : INTEGER ; iopar :^cbus_param_list ; VAR status : [OPTIONAL] status_type ); VAR st_fd : sptrg_per_fstd ; scalernum : INTEGER ; io_status : status_type ; BEGIN IF PRESENT(status) THEN status := ok ; { *** compute the correct sbsc relative scaler } st_fd := CONVERT(sptrg_per_fstd,sptrgnum DIV 4) ; { *** reset scalers } FOR scalernum := 25-(8*(sptrgnum MOD 4)) TO 31-(8*(sptrgnum MOD 4)) DO BEGIN reset_sbscaler ( TAGEXT := tagext, CARD := ADDRESS(sbscdis[st_fd]), REGISTER := ADDRESS(sbscdis[st_fd].datareg), IOPAR := iopar, SCALER := scalernum, SOFT_ENABLE := FALSE, STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Reset Veto Scaler #' + CONVERT(STRING,scalernum) ) ; IF PRESENT(status) THEN status := io_status ; END ; END ; {enable spare sbcaler to count via software} scalernum := 24-(8*(sptrgnum MOD 4)) ; reset_sbscaler ( TAGEXT := tagext, CARD := ADDRESS(sbscdis[st_fd]), REGISTER := ADDRESS(sbscdis[st_fd].datareg), IOPAR := iopar, SCALER := scalernum, SOFT_ENABLE := TRUE, STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Enabling Spare Veto Scaler ' ) ; IF PRESENT(status) THEN status := io_status ; END ; END ; { *************************************************************************** } { *************************************************************************** } PROCEDURE reset_sptrg_l15_scalers ( tagext : VARYING_STRING(8) := '' ; sptrgnum : INTEGER ; iopar :^cbus_param_list ; VAR status : [OPTIONAL] status_type ); VAR io_status : status_type ; BEGIN IF PRESENT(status) THEN status := ok ; { *** reset Level 1.5 cycle SBSC scaler } reset_sbscaler ( TAGEXT := tagext, CARD := ADDRESS(sbscL15_cyc_skp), REGISTER := ADDRESS(sbscL15_cyc_skp.datareg), IOPAR := iopar, SCALER := sptrgnum, SOFT_ENABLE := FALSE, STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Reset L1.5 Cycle Scaler' ) ; IF PRESENT(status) THEN status := io_status ; END ; { *** reset Level 1.5 skip SBSC scaler } reset_sbscaler ( TAGEXT := tagext, CARD := ADDRESS(sbscL15_cyc_skp), REGISTER := ADDRESS(sbscL15_cyc_skp.datareg), IOPAR := iopar, SCALER := 16 + sptrgnum, SOFT_ENABLE := FALSE, STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Reset L1.5 Skip Scaler' ) ; IF PRESENT(status) THEN status := io_status ; END ; { *** reset Level 1.5 Confirm SBSC scaler } reset_sbscaler ( TAGEXT := tagext, CARD := ADDRESS(sbscL15_cnf_rej), REGISTER := ADDRESS(sbscL15_cnf_rej.datareg), IOPAR := iopar, SCALER := sptrgnum, SOFT_ENABLE := FALSE, STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Reset L1.5 Confirm Scaler' ) ; IF PRESENT(status) THEN status := io_status ; END ; { *** reset Level 1.5 Reject SBSC scaler } reset_sbscaler ( TAGEXT := tagext, CARD := ADDRESS(sbscL15_cnf_rej), REGISTER := ADDRESS(sbscL15_cnf_rej.datareg), IOPAR := iopar, SCALER := 16 + sptrgnum, SOFT_ENABLE := FALSE, STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Reset L1.5 Reject Scaler' ) ; IF PRESENT(status) THEN status := io_status ; END ; { *** reset Level 1.5 cycle Dead Crossing scaler } reset_sbscaler ( TAGEXT := tagext, CARD := ADDRESS(sbscL15_dead_to), REGISTER := ADDRESS(sbscL15_dead_to.datareg), IOPAR := iopar, SCALER := sptrgnum, SOFT_ENABLE := FALSE, STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Reset L1.5 Dead X Scaler' ) ; IF PRESENT(status) THEN status := io_status ; END ; { *** reset Level 1.5 Timeout SBSC scaler } reset_sbscaler ( TAGEXT := tagext, CARD := ADDRESS(sbscL15_dead_to), REGISTER := ADDRESS(sbscL15_dead_to.datareg), IOPAR := iopar, SCALER := 16 + sptrgnum, SOFT_ENABLE := FALSE, STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Reset L1.5 timeout Scaler' ) ; IF PRESENT(status) THEN status := io_status ; END ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Level 1.5 Veto Scalers ' ) ; IF PRESENT(status) THEN status := io_status ; END ; END ; { *************************************************************************** } { *************************************************************************** } PROCEDURE load_rdtime ( tagext : VARYING_STRING(8) := '' ; sptrgnum : INTEGER ; rdtime : INTEGER ; VAR status : [OPTIONAL] status_type ); BEGIN IF PRESENT(status) THEN status := ok ; sptrg[sptrgnum]^.status.initialized := FALSE ; IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' COOR Specifying Readout Time' + ' for Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' to be ' + CONVERT(STRING,rdtime) + ' ms' ); sptrg[sptrgnum]^.read_time := rdtime ; END ; { *************************************************************************** } { *************************************************************************** } PROCEDURE autotune_sptrg ( tagext : VARYING_STRING(8) := '' ; sptrgset : set_of_sptrg ; iopar :^cbus_param_list ; VAR status :[OPTIONAL] status_type ); TYPE s_array (m,n:INTEGER) = ARRAY [m..n] OF INTEGER ; autotune_param = PACKED RECORD sptrgnum : INTEGER ; rate_mul_rdtime : REAL ; END ; VAR tot_involved : INTEGER ; trigger_list : ARRAY [1..32] OF autotune_param ; sptrgindex : INTEGER ; sptrgnum : INTEGER ; sbscalers_t1 :^s_array(0,31) ; sbscalers_t2 :^s_array(0,31) ; io_status : status_type ; swapper : autotune_param ; swap_count : INTEGER ; temp_sum : REAL ; temp_ratio : REAL ; temp_denom : REAL ; temp_rate : REAL ; BEGIN IF PRESENT(status) THEN status := ok ; NEW ( sbscalers_t1 ) ; NEW ( sbscalers_t2 ) ; {compute the total number of specific triggers involved} tot_involved := 0 ; FOR sptrgnum := firstsptrg TO lastsptrg DO IF ( CONVERT(sptrg_number,sptrgnum) IN sptrgset ) THEN BEGIN tot_involved := tot_involved + 1 ; trigger_list[tot_involved].sptrgnum := sptrgnum ; END ; {advertise} IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Tuning Prescalers of ' + CONVERT(STRING,tot_involved) + ' Spec Trig(s) # ' + list_sptrg_set(sptrgset) ) ; IF ( tot_involved = 0 ) THEN GOTO quit_autotune ; {disable involved specific triggers} FOR sptrgindex := 1 TO tot_involved DO BEGIN enable_global ( TAGEXT := tagext, SPTRGNUM := trigger_list[sptrgindex].sptrgnum, ENABLE := FALSE, IOPAR := iopar, STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF PRESENT(status) THEN status := io_status ; GOTO quit_autotune ; END ; END ; {read andor fired scalers} IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Reading Andor Fired Scalers and Waiting ' + CONVERT(STRING,ABS(autotune_sample_time) DIV 10000000) + ' s' ) ; read_sbscalers ( TAGEXT := tagext, CARD := ADDRESS(sbscaofired), REGISTER := ADDRESS(sbscaofired.datareg), IOPAR := iopar, SCALERS := sbscalers_t1, STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF PRESENT(status) THEN status := io_status ; GOTO quit_autotune ; END ; {wait some time} WAIT_ANY ( TIME := autotune_sample_time ) ; {read andor fired scalers again} IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Reading Andor Fired Scalers again' ) ; read_sbscalers ( TAGEXT := tagext, CARD := ADDRESS(sbscaofired), REGISTER := ADDRESS(sbscaofired.datareg), IOPAR := iopar, SCALERS := sbscalers_t2, STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF PRESENT(status) THEN status := io_status ; GOTO quit_autotune ; END ; {find products RiTi} FOR sptrgindex := 1 TO tot_involved DO BEGIN temp_rate := ( sbscalers_t2^[trigger_list[sptrgindex].sptrgnum] - sbscalers_t1^[trigger_list[sptrgindex].sptrgnum] ) / ( ABS(autotune_sample_time) / 10000 ) ; IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Andor Fired Rate for Spec Trig #' + CONVERT(STRING,trigger_list[sptrgindex].sptrgnum) + ' was ' + CONVERT(STRING,1000*temp_rate) + ' Hz' ) ; trigger_list[sptrgindex].rate_mul_rdtime := temp_rate * sptrg[trigger_list[sptrgindex].sptrgnum]^.read_time ; END ; {order by incresing RiTi} order_list: swap_count := 0 ; FOR sptrgindex := 1 TO tot_involved - 1 DO IF ( trigger_list[sptrgindex].rate_mul_rdtime > trigger_list[sptrgindex+1].rate_mul_rdtime ) THEN BEGIN swap_count := swap_count + 1 ; swapper := trigger_list[sptrgindex] ; trigger_list[sptrgindex] := trigger_list[sptrgindex+1] ; trigger_list[sptrgindex+1] := swapper ; END ; IF ( swap_count > 0 ) THEN GOTO order_list ; {compute and program prescale ratios} temp_sum := 0 ; FOR sptrgindex := 1 TO tot_involved DO BEGIN temp_denom := ( targ_acqbandw / 100 - temp_sum ) ; IF ( temp_denom <= 0 ) THEN temp_denom := 1E-20 ; temp_ratio := trigger_list[sptrgindex].rate_mul_rdtime * ( tot_involved + 1 - sptrgindex ) / temp_denom ; IF ( temp_ratio < 1 ) THEN temp_ratio := 1.0 ; temp_sum := temp_sum + trigger_list[sptrgindex].rate_mul_rdtime / ROUND(temp_ratio) ; prog_prescaler ( TAGEXT := tagext, SPTRGNUM := trigger_list[sptrgindex].sptrgnum, PRESCALE := TRUE, RATIO := ROUND(temp_ratio), IOPAR := iopar, STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF PRESENT(status) THEN status := io_status ; GOTO quit_autotune ; END ; END ; {reenable involved specific triggers} FOR sptrgindex := 1 TO tot_involved DO BEGIN enable_global ( TAGEXT := tagext, SPTRGNUM := trigger_list[sptrgindex].sptrgnum, ENABLE := TRUE, IOPAR := iopar, STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF PRESENT(status) THEN status := io_status ; GOTO quit_autotune ; END ; END ; quit_autotune : DISPOSE ( sbscalers_t1 ) ; DISPOSE ( sbscalers_t2 ) ; END ; { *************************************************************************** } { *************************************************************************** } PROCEDURE setup_force_db ( tagext : VARYING_STRING(16) := '' ; iopar :^cbus_param_list ; sptrgnum : INTEGER ) ; VAR aotermnum : INTEGER ; geosecnum : INTEGER ; BEGIN enable_autodis ( TAGEXT := tagext, SPTRGNUM := sptrgnum, AUTODIS := TRUE, IOPAR := iopar ) ; enable_global ( TAGEXT := tagext, SPTRGNUM := sptrgnum, ENABLE := TRUE, IOPAR := iopar ) ; prog_prescaler ( TAGEXT := tagext, SPTRGNUM := sptrgnum, PRESCALE := FALSE, RATIO := 1, IOPAR := iopar ) ; enable_obeybz ( TAGEXT := tagext, SPTRGNUM := sptrgnum, OBEYBZ := TRUE, IOPAR := iopar ) ; enable_obeyl2 ( TAGEXT := tagext, SPTRGNUM := sptrgnum, OBEYL2 := TRUE, IOPAR := iopar ) ; enable_obeybeam ( TAGEXT := tagext, SPTRGNUM := sptrgnum, OBEYBEAM := FALSE, IOPAR := iopar ) ; FOR geosecnum := firstgeosec TO lastgeosec DO BEGIN prog_startdgt ( TAGEXT := tagext, SPTRGNUM := sptrgnum, GEOSECNUM := geosecnum, DIGITIZE := FALSE, IOPAR := iopar ) ; prog_watchbusy ( TAGEXT := tagext, SPTRGNUM := sptrgnum, GEOSECNUM := geosecnum, WATCHBZ := FALSE, IOPAR := iopar ) ; END ; FOR aotermnum := firstaoterm TO lastaoterm DO prog_aoterm ( TAGEXT := tagext, SPTRGNUM := sptrgnum, AOTERMNUM := aotermnum, EXCLUDED := TRUE, IOPAR := iopar ) ; geosecnum := dbb_geosec ; prog_startdgt ( TAGEXT := tagext, SPTRGNUM := sptrgnum, GEOSECNUM := geosecnum, DIGITIZE := TRUE, IOPAR := iopar ) ; prog_watchbusy ( TAGEXT := tagext, SPTRGNUM := sptrgnum, GEOSECNUM := geosecnum, WATCHBZ := TRUE, IOPAR := iopar ) ; reset_sptrg_aofired_scaler ( TAGEXT := tagext, SPTRGNUM := sptrgnum, IOPAR := iopar ) ; reset_sptrg_fired_scaler ( TAGEXT := tagext, SPTRGNUM := sptrgnum, IOPAR := iopar ) ; reset_sptrg_exposed_scaler ( TAGEXT := tagext, SPTRGNUM := sptrgnum, IOPAR := iopar ) ; reset_sptrg_veto_scalers ( TAGEXT := tagext, SPTRGNUM := sptrgnum, IOPAR := iopar ) ; sptrg[sptrgnum]^.status.initialized := FALSE ; sptrg[sptrgnum]^.allocated := all_forcedb ; force_db_sptrg := sptrgnum ; force_db_mode := TRUE ; END ; { *************************************************************************** } { *************************************************************************** } FUNCTION list_sptrg_set ( sptrgset : set_of_sptrg ) : VARYING_STRING(80) ; VAR sptrgnum : INTEGER ; buffer : VARYING_STRING(80) ; BEGIN buffer := ' ' ; FOR sptrgnum := firstsptrg TO lastsptrg DO IF ( CONVERT(sptrg_number,sptrgnum) IN sptrgset ) THEN buffer := buffer + CONVERT(STRING,sptrgnum) + ', ' ; list_sptrg_set := buffer ; END ; { *************************************************************************** } { *************************************************************************** } PROCEDURE force_datablock ( tagext : VARYING_STRING(8) := '' ; iopar :^cbus_param_list ; VAR status :[OPTIONAL] status_type ) ; VAR fd_st : sptrg_per_fstd ; relst : relative_sptrg ; io_status : status_type ; BEGIN IF PRESENT(status) THEN status := ok ; IF ( force_db_mode = FALSE ) THEN BEGIN IF PRESENT(status) THEN status := not_found ; GOTO quit_forcedb ; END ELSE IF ( sptrg[force_db_sptrg]^.allocated <> all_forcedb ) THEN BEGIN force_db_mode := FALSE ; IF PRESENT(status) THEN status := not_found ; GOTO quit_forcedb ; END ; { *** compute the correct fstd cards relative number } fd_st := CONVERT(sptrg_per_fstd,force_db_sptrg DIV 4) ; relst := CONVERT(relative_sptrg,force_db_sptrg MOD 4) ; { *** set reenable bit high } sptrg[force_db_sptrg]^.enable.reenable := obey ; update_register ( TAGEXT := tagext, CARD := ADDRESS(fstd[fd_st]), REGISTER := ADDRESS(fstd[fd_st].enabreg[relst]), IOPAR := iopar, DATA := sptrg[force_db_sptrg]^.enable::BYTE , STATUS := io_status ) ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,force_db_sptrg) + ' Reenable Bit' ) ; IF PRESENT(status) THEN status := io_failure ; END ; { *** reset reenable bit low } sptrg[force_db_sptrg]^.enable.reenable := ignore ; update_register ( TAGEXT := tagext, CARD := ADDRESS(fstd[fd_st]), REGISTER := ADDRESS(fstd[fd_st].enabreg[relst]), IOPAR := iopar, DATA := sptrg[force_db_sptrg]^.enable::BYTE , STATUS := io_status ) ; quit_forcedb : END ; { *************************************************************************** } { *************************************************************************** } PROCEDURE level15_type ( tagext : VARYING_STRING(8) := '' ; sptrgnum : INTEGER ; level_15 : BOOLEAN := TRUE ; iopar :^cbus_param_list ; VAR status : [OPTIONAL] status_type ); VAR io_status : status_type ; step_status : status_type ; basereg : 0..7 ; basesptrg : 0..28 ; data : byte_by_bit ; BEGIN IF PRESENT(status) THEN status := ok ; sptrg[sptrgnum]^.status.initialized := FALSE ; { *** check on the previous state } IF ( level_15 = TRUE ) THEN BEGIN IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Setting Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Type Level 1.5' ) ; IF ( sptrg[sptrgnum]^.level_15 = TRUE ) THEN BEGIN IF PRESENT(status) THEN status := already_done ; IF ( inline_tracing(trace_warn) <> 0 ) THEN handle_trc_wrn ( TAG := tag + tagext, MESSAGE := ' Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Already of type Level 1.5' ) ; END ; END ELSE BEGIN IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Setting Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Type Pure Level 1' ) ; IF ( sptrg[sptrgnum]^.level_15 = FALSE ) THEN BEGIN IF PRESENT(status) THEN status := already_done ; IF ( inline_tracing(trace_warn) <> 0 ) THEN handle_trc_wrn ( TAG := tag + tagext, MESSAGE := ' Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Already Pure Level 1' ) ; END ; END ; { *** modify the physics data base } sptrg[sptrgnum]^.level_15 := level_15 ; { *** compute the correct digimem register indices } basereg := sptrgnum DIV 4 ; basesptrg := sptrgnum - ( sptrgnum MOD 4 ) ; { *** setup the hardware } { *** program the l1.5 control DGM to find when a pure Level 1 trigger fired.} { Require all ST programmed NOT requiring L1.5 confirmation to be LOW, } { don't care for all other inputs. Output will be ACTIVE LOW and } { must be inverted in wire wrap. } data::BYTE := 15 ; { all bits will be required low when included } data.bit4 := sptrg[basesptrg+0]^.level_15::byte ; {a bit is required when } data.bit5 := sptrg[basesptrg+1]^.level_15::byte ; {it corresponds to a pure } data.bit6 := sptrg[basesptrg+2]^.level_15::byte ; {Level 1 Specific trigger } data.bit7 := sptrg[basesptrg+3]^.level_15::byte ; { FALSE = 0 = required } update_register ( TAGEXT := tagext, CARD := ADDRESS(dgmL15_ctrl), REGISTER := ADDRESS(dgmL15_ctrl.PL1_fired[basereg]), IOPAR := iopar, DATA := data::byte, STATUS := step_status ) ; IF ( step_status = io_failure ) THEN io_status := io_failure ; { *** program the l1.5 control DGM to find when a Level 1.5 trigger fired. } { Require all ST programmed requiring L1.5 confirmation to be LOW, } { don't care for all other inputs. Output will be ACTIVE LOW and } { must be inverted in wire wrap. } data.bit4 := 1 - data.bit4 ; { a bit is required when } data.bit5 := 1 - data.bit5 ; { it corresponds to a Level 1.5 } data.bit6 := 1 - data.bit6 ; { Specific trigger } data.bit7 := 1 - data.bit7 ; { 0 = required } update_register ( TAGEXT := tagext, CARD := ADDRESS(dgmL15_ctrl), REGISTER := ADDRESS(dgmL15_ctrl.L15_fired[basereg]), IOPAR := iopar, DATA := data::byte, STATUS := step_status ) ; IF ( step_status = io_failure ) THEN io_status := io_failure ; { *** program the l1.5 control DGM to find when a L1.5 trigger is confirmed } { Require all ST programmed requiring L1.5 confirmation to be LOW, } { don't care for all other inputs. Output will be ACTIVE LOW and } { must be inverted in wire wrap. } update_register ( TAGEXT := tagext, CARD := ADDRESS(dgmL15_ctrl), REGISTER := ADDRESS(dgmL15_ctrl.L15_confirmed[basereg]), IOPAR := iopar, DATA := data::byte, STATUS := step_status ) ; IF ( step_status = io_failure ) THEN io_status := io_failure ; { now setup the veto / confirm MTG } IF ( level_15 = TRUE ) THEN BEGIN { enable the confirmation of this specific trigger } update_register ( TAGEXT := tagext, CARD := ADDRESS(mtgL15_vc), REGISTER := ADDRESS(mtgL15_vc.channelreg[sptrgnum]), IOPAR := iopar, DATA := tss_l15_confirm_enb, STATUS := step_status ) ; IF ( step_status = io_failure ) THEN io_status := io_failure ; { enable the veto-ing of this specific trigger } update_register ( TAGEXT := tagext, CARD := ADDRESS(mtgL15_vc), REGISTER := ADDRESS(mtgL15_vc.channelreg[16+sptrgnum]), IOPAR := iopar, DATA := tss_l15_veto_enb, STATUS := step_status ) ; IF ( step_status = io_failure ) THEN io_status := io_failure ; END ELSE BEGIN { force low the confirmation of this specific trigger } update_register ( TAGEXT := tagext, CARD := ADDRESS(mtgL15_vc), REGISTER := ADDRESS(mtgL15_vc.channelreg[sptrgnum]), IOPAR := iopar, DATA := tss_l15_confirm_low, STATUS := step_status ) ; IF ( step_status = io_failure ) THEN io_status := io_failure ; { force low the veto-ing of this specific trigger } update_register ( TAGEXT := tagext, CARD := ADDRESS(mtgL15_vc), REGISTER := ADDRESS(mtgL15_vc.channelreg[16+sptrgnum]), IOPAR := iopar, DATA := tss_l15_veto_low, STATUS := step_status ) ; IF ( step_status = io_failure ) THEN io_status := io_failure ; END ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' for Level 1.5' ) ; IF PRESENT(status) THEN status := io_status ; END ; END ; { *************************************************************************** } { *************************************************************************** } PROCEDURE prog_l15confirm ( tagext : VARYING_STRING(8) := '' ; sptrgnum : INTEGER ; l15termnum : INTEGER ; require : BOOLEAN := TRUE ; iopar :^cbus_param_list ; VAR status : [OPTIONAL] status_type ); VAR st_dg : sptrg_per_digm ; relst : relative_sptrg ; io_status : status_type ; basel15term : 0..28 ; basereg : 0..7 ; data : byte_by_bit ; BEGIN IF PRESENT(status) THEN status := ok ; sptrg[sptrgnum]^.status.initialized := FALSE ; { *** check on the previous state } IF ( require = TRUE ) THEN BEGIN IF ( inline_tracing(trace_info) <> 0 ) THEN handle_trc_inf ( TAG := tag + tagext, MESSAGE := ' Setting Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Requiring Level 1.5 Term #' + CONVERT(STRING,l15termnum) ) ; IF ( sptrg[sptrgnum]^.l15term[l15termnum] = 1 ) THEN BEGIN IF PRESENT(status) THEN status := already_done ; IF ( inline_tracing(trace_warn) <> 0 ) THEN handle_trc_wrn ( TAG := tag + tagext, MESSAGE := ' Spec Trig #' + CONVERT(STRING,sptrgnum) + ' Already Requiring Level 1.5 Term #' + CONVERT(STRING,l15termnum) ) ; END ; END ; { *** modify the physics data base } IF ( require = TRUE ) THEN sptrg[sptrgnum]^.l15term[l15termnum] := 1 ELSE sptrg[sptrgnum]^.l15term[l15termnum] := 0 ; { *** compute the correct digimem card indices } st_dg := CONVERT ( sptrg_per_digm, sptrgnum DIV 4 ) ; relst := CONVERT ( relative_sptrg, sptrgnum MOD 4 ) ; basereg := l15termnum DIV 4 ; basel15term := l15termnum - ( l15termnum MOD 4 ) ; { *** program the apropriate done/answer DGM to require the Level 1.5 term } { Require all Level 1.5 terms in the L1.5 confirmation to be HIGH, } { don't care for all other inputs. Output will be ACTIVE HIGH and } { this programming fits both of the done and answer halgf cycles } data::BYTE := 0 ; { all bits required high when included } data.bit4 := 1 - sptrg[sptrgnum]^.l15term[basel15term+0] ; {a bit is required} data.bit5 := 1 - sptrg[sptrgnum]^.l15term[basel15term+1] ; {if a Level 1.5 } data.bit6 := 1 - sptrg[sptrgnum]^.l15term[basel15term+2] ; {term is required } data.bit7 := 1 - sptrg[sptrgnum]^.l15term[basel15term+3] ; {for confirmation } { *** modify the hardware data base } update_register ( TAGEXT := tagext, CARD := ADDRESS(dgmL15_ans[st_dg]), REGISTER := ADDRESS(dgmL15_ans[st_dg].netreg[relst,basereg]), IOPAR := iopar, DATA := data::BYTE, STATUS := io_status ) ; IF ( require = TRUE ) THEN BEGIN { enable the receiving and multiplexing of this level 1.5 term } update_register ( TAGEXT := tagext, CARD := ADDRESS(mtgL15_mux), REGISTER := ADDRESS(mtgL15_mux.channelreg[l15termnum]), IOPAR := iopar, DATA := tss_l15_receive_enb, STATUS := io_status ) ; END ; IF ( io_status = io_failure ) THEN BEGIN IF ( inline_tracing(trace_error) <> 0 ) THEN handle_trc_err ( TAG := tag + tagext, MESSAGE := ' Failure Programming Spec Trigger #' + CONVERT(STRING,sptrgnum) + ' Requiring Level 1.5 Term #' + CONVERT(STRING,l15termnum) ) ; IF PRESENT(status) THEN status := io_status ; END ; END ; { *************************************************************************** } { *************************************************************************** } PROCEDURE show_sptrg ( tagext : VARYING_STRING(8) := '' ; sptrgnum : INTEGER ; iopar :^cbus_param_list ; VAR status : [OPTIONAL] status_type ); VAR st_ds : sptrg_per_dbsc ; relst : relative_sptrg ; st_fd : sptrg_per_fstd ; aotermnum : INTEGER ; geosecnum : INTEGER ; l15termnum : INTEGER ; reqhibuf : VARYING_STRING(80) ; reqlobuf : VARYING_STRING(80) ; stdigbuf : VARYING_STRING(80) ; wbusybuf : VARYING_STRING(80) ; l15term : VARYING_STRING(80) ; io_status : status_type ; scbase : INTEGER ; BEGIN IF PRESENT(status) THEN status := ok ; { *** compute the correct dbsc relative scaler } st_ds := CONVERT(sptrg_per_dbsc,sptrgnum DIV 2) ; relst := CONVERT(relative_sptrg,sptrgnum MOD 2) ; { *** compute the correct sbsc relative scaler } st_fd := CONVERT(sptrg_per_fstd,sptrgnum DIV 4) ; handle_trc_inf ( TAG := tag, MESSAGE := ' Current Programming of Specific Trigger #' + CONVERT(STRING,sptrgnum) + ' -->' ) ; IF ( sptrg[sptrgnum]^.allocated = ALL_NONE ) THEN handle_trc_inf ( MESSAGE := ' Not Allocated ' ) ELSE IF ( sptrg[sptrgnum]^.allocated = ALL_COOR ) THEN handle_trc_inf ( MESSAGE := ' Allocated to COOR ' ) ; IF ( sptrg[sptrgnum]^.enable.globaldis = OBEY ) THEN handle_trc_inf ( MESSAGE := ' Now Globally Disabled ' ) ELSE handle_trc_inf ( MESSAGE := ' Now Globally Enabled ' ) ; IF ( sptrg[sptrgnum]^.enable.fendbz = OBEY ) THEN handle_trc_inf ( MESSAGE := ' Obey Front End Busy Signals ' ) ELSE handle_trc_inf ( MESSAGE := ' Ignore Front End Busy Signals ' ) ; IF ( sptrg[sptrgnum]^.enable.level2 = OBEY ) THEN handle_trc_inf ( MESSAGE := ' Obey Level 2 Disable ' ) ELSE handle_trc_inf ( MESSAGE := ' Ignore Level 2 Disable ' ) ; IF ( sptrg[sptrgnum]^.enable.Beam = OBEY ) THEN handle_trc_inf ( MESSAGE := ' Obey Beam Veto ' ) ELSE handle_trc_inf ( MESSAGE := ' Ignore Beam Veto ' ) ; IF ( sptrg[sptrgnum]^.enable.autodis = OBEY ) THEN handle_trc_inf ( MESSAGE := ' Set For Autodisable Mode ' ) ELSE handle_trc_inf ( MESSAGE := ' Not Set For Autodisable Mode ' ) ; handle_trc_inf ( MESSAGE := ' Total Available Acquisition Bandwidth is ' + CONVERT(STRING,targ_acqbandw) + '% ' ) ; handle_trc_inf ( MESSAGE := ' Readout Time of this Spec Trig is ' + CONVERT(STRING,sptrg[sptrgnum]^.read_time) + ' ms ' ) ; IF ( sptrg[sptrgnum]^.enable.prsc = OBEY ) THEN handle_trc_inf ( MESSAGE := ' Prescaled by ' + CONVERT(STRING,sptrg[sptrgnum]^.prscratio) ) ELSE handle_trc_inf ( MESSAGE := ' Not Prescaled ' ) ; reqhibuf := '' ; reqlobuf := ''; FOR aotermnum := firstaoterm TO lastaoterm DO IF ( sptrg[sptrgnum]^.aoterm[aotermnum].excluded = 0 ) THEN BEGIN IF ( sptrg[sptrgnum]^.aoterm[aotermnum].polarity = 1 ) THEN reqhibuf := reqhibuf + CONVERT(STRING,aotermnum) + ' ' ELSE reqlobuf := reqlobuf + CONVERT(STRING,aotermnum) + ' ' ; END ; IF ( reqhibuf <> '' ) THEN handle_trc_inf ( MESSAGE := ' Requires High Andor Term(s) # ' + reqhibuf ) ; IF ( reqlobuf <> '' ) THEN handle_trc_inf ( MESSAGE := ' Requires Low Andor Term(s) # ' + reqlobuf ) ; IF ( ( reqhibuf = '' ) AND ( reqlobuf = '' ) ) THEN handle_trc_inf ( MESSAGE := ' Does Not Require Any Andor Term ' ) ; stdigbuf := '' ; wbusybuf := '' ; FOR geosecnum := firstgeosec TO lastgeosec DO BEGIN IF ( sptrg[sptrgnum]^.geosec[geosecnum].digitize = 1 ) THEN stdigbuf := stdigbuf + CONVERT(STRING,geosecnum) + ' ' ; IF ( sptrg[sptrgnum]^.geosec[geosecnum].watchbz = 1 ) THEN wbusybuf := wbusybuf + CONVERT(STRING,geosecnum) + ' ' ; END ; IF ( stdigbuf <> '' ) THEN handle_trc_inf ( MESSAGE := ' Digitizes Geo Section(s) # ' + stdigbuf ) ELSE handle_trc_inf ( MESSAGE := ' Does Not Digitize Any Geo Section' ) ; IF ( wbusybuf <> '' ) THEN handle_trc_inf ( MESSAGE := ' Can Be Disabled By Geo Section(s) # ' + wbusybuf ) ELSE handle_trc_inf ( MESSAGE := ' Cannot Be Disabled By Any Geo Section') ; IF ( sptrg[sptrgnum]^.level_15 = TRUE ) THEN handle_trc_inf ( MESSAGE := ' Level 1.5 Trigger ' ) ELSE handle_trc_inf ( MESSAGE := ' Pure Level 1 Trigger ' ) ; l15term := '' ; FOR l15termnum := firstl15term TO lastl15term DO BEGIN IF ( sptrg[sptrgnum]^.l15term[l15termnum] = 1 ) THEN l15term := l15term + CONVERT(STRING,l15termnum) + ' ' ; END ; IF ( l15term <> '' ) THEN handle_trc_inf ( MESSAGE := ' Requires Level 1.5 Term(s) # ' + l15term ) ELSE handle_trc_inf ( MESSAGE := ' Does Not Require any Level 1.5 Term' ) ; {load_sbscalers ( IOPAR := iopar ) ;} read_sbscalers ( TAGEXT := tagext, CARD := ADDRESS(sbscaofired), REGISTER := ADDRESS(sbscaofired.datareg), { LOADED := TRUE,} IOPAR := iopar, STATUS := io_status ) ; IF ( io_status = io_failure ) THEN IF PRESENT(status) THEN status := io_status ; handle_trc_inf ( MESSAGE := ' Andor Fired Scaler : %X_' + HEX(iopar^.a_sbsc[4,sptrgnum],2,2) + HEX(iopar^.a_sbsc[3,sptrgnum],2,2) + HEX(iopar^.a_sbsc[2,sptrgnum],2,2) + HEX(iopar^.a_sbsc[1,sptrgnum],2,2) ) ; read_dbscaler ( TAGEXT := tagext, CARD := ADDRESS(dbsc[st_ds]), REGISTER := ADDRESS(dbsc[st_ds].resetreg[relst,exposc]), IOPAR := iopar ) ; handle_trc_inf ( MESSAGE := ' SpTrg Fired Scaler : %X_' + HEX(iopar^.a_dbsc[5],2,2) + HEX(iopar^.a_dbsc[4],2,2) + HEX(iopar^.a_dbsc[3],2,2) + HEX(iopar^.a_dbsc[2],2,2) + HEX(iopar^.a_dbsc[1],2,2) ) ; read_dbscaler ( TAGEXT := tagext, CARD := ADDRESS(dbsc[st_ds]), REGISTER := ADDRESS(dbsc[st_ds].resetreg[relst,exposc]), IOPAR := iopar ) ; handle_trc_inf ( MESSAGE := ' Exposition Scaler : %X_' + HEX(iopar^.a_dbsc[5],2,2) + HEX(iopar^.a_dbsc[4],2,2) + HEX(iopar^.a_dbsc[3],2,2) + HEX(iopar^.a_dbsc[2],2,2) + HEX(iopar^.a_dbsc[1],2,2) ) ; read_sbscalers ( TAGEXT := tagext, CARD := ADDRESS(sbscdis[st_fd]), REGISTER := ADDRESS(sbscdis[st_fd].datareg), { LOADED := TRUE,} IOPAR := iopar, STATUS := io_status ) ; IF ( io_status = io_failure ) THEN IF PRESENT(status) THEN status := io_status ; scbase := 25-(8*(sptrgnum MOD 4)) ; handle_trc_inf ( MESSAGE := ' Disable Scalers : ' + ' Autods=%X_' + HEX(iopar^.a_sbsc[4,scbase+0],2,2) + HEX(iopar^.a_sbsc[3,scbase+0],2,2) + HEX(iopar^.a_sbsc[2,scbase+0],2,2) + HEX(iopar^.a_sbsc[1,scbase+0],2,2) + ' Global=%X_' + HEX(iopar^.a_sbsc[4,scbase+1],2,2) + HEX(iopar^.a_sbsc[3,scbase+1],2,2) + HEX(iopar^.a_sbsc[2,scbase+1],2,2) + HEX(iopar^.a_sbsc[1,scbase+1],2,2) + ' Auxilr=%X_' + HEX(iopar^.a_sbsc[4,scbase+2],2,2) + HEX(iopar^.a_sbsc[3,scbase+2],2,2) + HEX(iopar^.a_sbsc[2,scbase+2],2,2) + HEX(iopar^.a_sbsc[1,scbase+2],2,2) ) ; handle_trc_inf ( MESSAGE := ' Fr-end=%X_' + HEX(iopar^.a_sbsc[4,scbase+3],2,2) + HEX(iopar^.a_sbsc[3,scbase+3],2,2) + HEX(iopar^.a_sbsc[2,scbase+3],2,2) + HEX(iopar^.a_sbsc[1,scbase+3],2,2) + ' Lev2.0=%X_' + HEX(iopar^.a_sbsc[4,scbase+4],2,2) + HEX(iopar^.a_sbsc[3,scbase+4],2,2) + HEX(iopar^.a_sbsc[2,scbase+4],2,2) + HEX(iopar^.a_sbsc[1,scbase+4],2,2) + ' Lev1.5=%X_' + HEX(iopar^.a_sbsc[4,scbase+5],2,2) + HEX(iopar^.a_sbsc[3,scbase+5],2,2) + HEX(iopar^.a_sbsc[2,scbase+5],2,2) + HEX(iopar^.a_sbsc[1,scbase+5],2,2) + ' Prescl=%X_' + HEX(iopar^.a_sbsc[4,scbase+6],2,2) + HEX(iopar^.a_sbsc[3,scbase+6],2,2) + HEX(iopar^.a_sbsc[2,scbase+6],2,2) + HEX(iopar^.a_sbsc[1,scbase+6],2,2) ) ; END ; { *************************************************************************** } { *************************************************************************** } END .