fevmemodules.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include "midas.h"
#include "mvmestd.h"
#include "vmicvme.h"
#include "vmeio.h"
#include "v1190B.h"
#include "v792.h"
#include "vf48.h"
#include "v1729.h"
#include "experim.h"

Include dependency graph for fevmemodules.c:

Go to the source code of this file.

Macros
#define	VF48_CODE
#define	P_BOE   0x1
#define	P_EOE   0x2
#define	P_CLR   0x4
#define	S_READOUT   0x8
#define	S_RUNGATE   0x10
#define	TRIG_LEVEL   (int) 1
#define	INT_LEVEL   (int) 3
#define	INT_VECTOR   (int) 0x16
#define	N_ADC   100
#define	N_TDC   100
#define	N_PTS   5000
#define	N_SCLR   4

Functions
INT	frontend_init ()
	Frontend initialization.
INT	frontend_exit ()
	Frontend exit.
INT	begin_of_run (INT run_number, char *error)
	Begin of Run.
INT	end_of_run (INT run_number, char *error)
	End of Run.
INT	pause_run (INT run_number, char *error)
	Pause Run.
INT	resume_run (INT run_number, char *error)
	Resume Run.
INT	frontend_loop ()
	Frontend loop.
void	interrupt_routine (void)
INT	read_trigger_event (char *pevent, INT off)
INT	read_scaler_event (char *pevent, INT off)
	Scaler event readout.
void	register_cnaf_callback (int debug)
void	seq_callback (INT hDB, INT hseq, void *info)
INT	poll_event (INT source, INT count, BOOL test)
	Polling routine for events.
INT	interrupt_configure (INT cmd, INT source, PTYPE adr)

Variables
int	trig_level = 0
INT_INFO	int_info
int	myinfo = VME_INTERRUPT_SIGEVENT
char *	frontend_name = "fevmemodules"
	The frontend name (client name) as seen by other MIDAS clients.
char *	frontend_file_name = __FILE__
	The frontend file name, don't change it.
BOOL	frontend_call_loop = FALSE
	frontend_loop is called periodically if this variable is TRUE
INT	display_period = 000
	a frontend status page is displayed with this frequency in ms
INT	max_event_size = 200000
	maximum event size produced by this frontend
INT	max_event_size_frag = 5 * 1024 * 1024
	maximum event size for fragmented events (EQ_FRAGMENTED)
INT	event_buffer_size = 10 * 100000
	buffer size to hold events
MVME_INTERFACE *	myvme
int	sRG = 0
int	intflag = 0
int	inRun = 0
int	missed =0
int	done =0
int	stop_req =0
DWORD	evlimit
DWORD	VMEIO_BASE = 0x780000
DWORD	VTDC0_BASE = 0xF10000
DWORD	VADC0_BASE = 0x100000
DWORD	VADC1_BASE = 0x200000
DWORD	VADC2_BASE = 0x300000
DWORD	VADC3_BASE = 0x400000
DWORD	VLAM_BASE = 0x800000
DWORD	VF48_BASE = 0xAF0000
DWORD	V1729_BASE = 0x120000
HNDLE	hDB
	main ODB handle
HNDLE	hSet
TRIGGER_SETTINGS	ts
BANK_LIST	trigger_bank_list []
EQUIPMENT	equipment []
	Main structure for midas equipment.
int	vf48_error = 0

Macro Definition Documentation

INT_LEVEL

#define INT_LEVEL   (int) 3

Definition at line 45 of file fevmemodules.c.

INT_VECTOR

#define INT_VECTOR   (int) 0x16

Definition at line 46 of file fevmemodules.c.

N_ADC

#define N_ADC   100

Definition at line 97 of file fevmemodules.c.

N_PTS

#define N_PTS   5000

Definition at line 99 of file fevmemodules.c.

N_SCLR

#define N_SCLR   4

Definition at line 105 of file fevmemodules.c.

N_TDC

#define N_TDC   100

Definition at line 98 of file fevmemodules.c.

P_BOE

#define P_BOE   0x1

Definition at line 36 of file fevmemodules.c.

P_CLR

#define P_CLR   0x4

Definition at line 38 of file fevmemodules.c.

P_EOE

#define P_EOE   0x2

Definition at line 37 of file fevmemodules.c.

S_READOUT

#define S_READOUT   0x8

Definition at line 39 of file fevmemodules.c.

S_RUNGATE

#define S_RUNGATE   0x10

Definition at line 40 of file fevmemodules.c.

TRIG_LEVEL

#define TRIG_LEVEL   (int) 1

Definition at line 44 of file fevmemodules.c.

VF48_CODE

#define VF48_CODE

Definition at line 19 of file fevmemodules.c.

Function Documentation

begin_of_run()

INT begin_of_run	(	INT	run_number,
		char *	error
	)

Begin of Run.

Called every run start transition. Set equipment status in ODB, start acquisition on the modules.

Parameters

[in]	run_number	Number of the run being started
[out]	error	Can be used to write a message string to midas.log

Definition at line 285 of file fevmemodules.c.

{
  int i, csr, status, size;
   /* put here clear scalers etc. */
 
  /* read Triggger settings */
  size = sizeof(TRIGGER_SETTINGS);
  if ((status = db_get_record (hDB, hSet, &ts, &size, 0)) != DB_SUCCESS)
    return status;
 
  // Set am to A24 non-privileged Data
  mvme_set_am(myvme, MVME_AM_A24_ND);
  
  // Set dmode to D32
  mvme_set_dmode(myvme, MVME_DMODE_D32);
  
#if defined VTDC0_CODE
  //-------- TDCs -------------------------------------------
  // Check the TDC
  csr = mvme_read_value(myvme, VTDC0_BASE+V1190_FIRM_REV_RO);
  printf("Firmware revision: 0x%x\n", csr);
  
  // Set mode 1
  v1190_Setup(myvme, VTDC0_BASE, 1);
 
  if (ts.v1190.leresolution == 100)
    temp = LE_RESOLUTION_100;
  else if (ts.v1190.leresolution == 200)
    temp = LE_RESOLUTION_200;
  else if (ts.v1190.leresolution == 800)
    temp = LE_RESOLUTION_800;
  else
    temp = 3;
  if (temp != 2)
    v1190_LEResolutionSet(myvme, VTDC0_BASE, temp);
 
  // Adjust window width to 10us 
  // 10us == 0x18F
  temp = (DWORD) abs(ts.v1190.windowwidth / 25e-9);
  v1190_WidthSet(myvme, VTDC0_BASE, temp);
 
  // Adjust offset width to 10us 
  // 10us == 0xE70
  temp = ts.v1190.windowoffset / 25e-9;
  temp = temp < 0 ? ((DWORD)temp&0xFFF): (DWORD) temp;
  v1190_OffsetSet(myvme, VTDC0_BASE, temp);
 
  // Print Current status 
  printf("BOR : FELIXE V1190B settings\n");
  v1190_Status(myvme, VTDC0_BASE);
#endif
 
#if defined V792_CODE
  //-------- ADCs ------------------------------------------
  printf("ADC0\n");
  v792_Setup(myvme, VADC0_BASE, 2);
  printf("ADC1\n");
  v792_Setup(myvme, VADC1_BASE, 2);
  printf("ADC2\n");
  v792_Setup(myvme, VADC2_BASE, 2);
  printf("ADC3\n");
  v792_Setup(myvme, VADC3_BASE, 2);
 
  /* Initialize the V792s ADC0 --*/
  /* Load Threshold */
  for (i=0;i<V792_MAX_CHANNELS;i+=2) {
    printf("B Threshold[%i] = 0x%4.4x\t   -  ", i, ts.v792.threshold1[i]);
    printf("Threshold[%i] = 0x%4.4x\n", i+1, ts.v792.threshold1[i+1]);
  }
  v792_ThresholdWrite(myvme, VADC0_BASE, (WORD *)&(ts.v792.threshold1));
  
  for (i=0;i<V792_MAX_CHANNELS;i+=2) {
    printf("Threshold[%i] = 0x%4.4x\t   -  ", i, ts.v792.threshold1[i]);
    printf("Threshold[%i] = 0x%4.4x\n", i+1, ts.v792.threshold1[i+1]);
  }
 
  v792_DataClear(myvme, VADC0_BASE);
  csr = v792_CSR1Read(myvme, VADC0_BASE);
  printf("Data Ready ADC0: 0x%x\n", csr);
  
  /* Initialize the V792s ADC1 --*/
  /* Load Threshold */
  v792_ThresholdWrite(myvme, VADC1_BASE, (WORD *)&(ts.v792.thresholds2));
  v792_DataClear(myvme, VADC1_BASE);
  csr = v792_CSR1Read(myvme, VADC1_BASE);
  printf("Data Ready ADC1: 0x%x\n", csr);
  
  /* Initialize the V792s ADC2 --*/
  /* Load Threshold */
  v792_ThresholdWrite(myvme, VADC2_BASE, (WORD *)&(ts.v792.thresholds3));
  v792_DataClear(myvme, VADC2_BASE);
  csr = v792_CSR1Read(myvme, VADC2_BASE);
  printf("Data Ready ADC2: 0x%x\n", csr);
  
  /* Initialize the V792s ADC3 --*/
  /* Load Threshold */
  v792_ThresholdWrite(myvme, VADC3_BASE, (WORD *)&(ts.v792.thresold4));
  v792_DataClear(myvme, VADC3_BASE);
  csr = v792_CSR1Read(myvme, VADC3_BASE);
  printf("Data Ready ADC3: 0x%x\n", csr);
#endif
 
 
#if defined V1729_CODE
  //-------- 1/2 Gsps ADC (CAEN) -------------------------------------
  // Set mode 3 (128 full range)
  v1729_Setup(myvme, V1729_BASE, 3);
  v1729_PostTrigSet(myvme, V1729_BASE, ts.v1729.post_trigger);
 
  // Print Current status
  v1729_Status(myvme, V1729_BASE);
 
  // Start acquisition
  v1729_AcqStart(myvme, V1729_BASE);
#endif
 
#if defined VF48_CODE
  //-------- 20..65 Msps ADC (Uni Montreal) -------------------------
  /* Initialize the VF48 --*/
  vf48_Reset(myvme, VF48_BASE);
 
  // Stop DAQ for seting up the parameters
  vf48_AcqStop(myvme, VF48_BASE);
    
  if (ts.vf48.external_trigger) {
    vf48_ExtTrgSet(myvme, VF48_BASE);
    printf("vf48: External trigger mode\n");
  } else {
    vf48_ExtTrgClr(myvme, VF48_BASE);
    printf("vf48: Self triggering mode\n");
  }
  csr = vf48_CsrRead(myvme, VF48_BASE);
  printf("CSR Buffer: 0x%x\n", csr);
 
  // Segment Size
  vf48_SegmentSizeSet(myvme, VF48_BASE, ts.vf48.segment_size);
    for (i=0;i<6;i++) {
      printf("vf48: SegSize grp (%d) %i:%d\n", ts.vf48.segment_size
        , i, vf48_SegmentSizeRead(myvme, VF48_BASE, i));
    }
 
  // Set Threshold high for external trigger, as the 
  // the self-trigger is always sending info to the collector 
  // and overwhelming the link. (max maybe 10 bits (0x3FF))
  // Threshold
  for (i=0;i<6;i++) {
    vf48_TrgThresholdSet(myvme, VF48_BASE, i, ts.vf48.trigger_threshold);
      printf("vf48: Trigger Threshold grp (%d) %i:%d\n", ts.vf48.trigger_threshold
        , i, vf48_TrgThresholdRead(myvme, VF48_BASE, i));
  }
 
  // Set Threshold high for Hit detection
  for (i=0;i<6;i++) {
    vf48_HitThresholdSet(myvme, VF48_BASE, i, ts.vf48.hit_threshold);
      printf("vf48: Hit Threshold grp (%d) %i:%d\n", ts.vf48.hit_threshold
        , i, vf48_HitThresholdRead(myvme, VF48_BASE, i));
  }
 
  // Active Channel Mask
  for (i=0;i<6;i++){
    vf48_ActiveChMaskSet(myvme, VF48_BASE, i, ts.vf48.active_channel_mask);
    printf("vf48: Active channel mask grp (%x) %i:0x%x\n", ts.vf48.active_channel_mask
      , i, vf48_ActiveChMaskRead(myvme, VF48_BASE, i));
  }
 
  // Raw Data Suppression
  for (i=0;i<6;i++){
    vf48_RawDataSuppSet(myvme, VF48_BASE, i, ts.vf48.raw_data_suppress);
    printf("vf48: Raw Data Suppress grp (%x) %i:0x%x\n", ts.vf48.raw_data_suppress
      , i, vf48_RawDataSuppRead(myvme, VF48_BASE, i));
  }
 
  // Channel Suppress Enable
  for (i=0;i<6;i++){
    vf48_ChSuppSet(myvme, VF48_BASE, i, ts.vf48.channel_suppress_enable);
    printf("vf48: Channel Suppression Enable grp (%x) %i:0x%x\n", ts.vf48.channel_suppress_enable
      , i, 0x1 & vf48_ChSuppRead(myvme, VF48_BASE, i));
  }
 
  // Divisor
  vf48_DivisorWrite(myvme, VF48_BASE, ts.vf48.divisor);
  for (i=0;i<6;i++){
    printf("vf48: Divisor grp (%x) %i:0x%x\n", ts.vf48.divisor
      , i, vf48_DivisorRead(myvme, VF48_BASE, i));
  }
 
  // PreTrigger
  for (i=0;i<6;i++) {
    vf48_ParameterWrite(myvme, VF48_BASE, i, VF48_PRE_TRIGGER, ts.vf48.pretrigger);
    printf("vf48: Pre Trigger grp %i:%d\n"
      , i, vf48_ParameterRead(myvme, VF48_BASE, i, VF48_PRE_TRIGGER));
  }
 
  // Latency
  for (i=0;i<6;i++) {
    vf48_ParameterWrite(myvme, VF48_BASE, i, VF48_LATENCY, ts.vf48.latency);
    printf("vf48: Latency grp %i:%d\n"
      , i, vf48_ParameterRead(myvme, VF48_BASE, i, VF48_LATENCY));
  }
 
  // K-coef
  for (i=0;i<6;i++) {
    vf48_ParameterWrite(myvme, VF48_BASE, i, VF48_K_COEF, ts.vf48.k_coeff);
    printf("vf48: K-coeff grp %i:%d\n"
      , i, vf48_ParameterRead(myvme, VF48_BASE, i, VF48_K_COEF));
  }
  // L-coef
  for (i=0;i<6;i++) {
    vf48_ParameterWrite(myvme, VF48_BASE, i, VF48_L_COEF, ts.vf48.l_coeff);
    printf("vf48: L-coeff grp %i:%d\n"
      , i, vf48_ParameterRead(myvme, VF48_BASE, i, VF48_L_COEF));
  }
  // M-coef
  for (i=0;i<6;i++) {
    vf48_ParameterWrite(myvme, VF48_BASE, i, VF48_M_COEF, ts.vf48.m_coeff);
    printf("vf48: M-coeff grp %i:%d\n"
      , i, vf48_ParameterRead(myvme, VF48_BASE, i, VF48_M_COEF));
  }
 
  // Polarity
  for (i=0;i<6;i++) {
    DWORD pat;
    if (ts.vf48.inverse_signal){
      pat = vf48_ParameterRead(myvme, VF48_BASE, i, VF48_MBIT1);
      pat |= VF48_INVERSE_SIGNAL;
      vf48_ParameterWrite(myvme, VF48_BASE, i, VF48_MBIT1, pat);
    } else {
      pat = vf48_ParameterRead(myvme, VF48_BASE, i, VF48_MBIT1);
      pat &= ~(VF48_INVERSE_SIGNAL);
      vf48_ParameterWrite(myvme, VF48_BASE, i, VF48_MBIT1, pat);
    }
    printf("vf48: Polarity grp %i:%d\n"
      , i, vf48_ParameterRead(myvme, VF48_BASE, i, VF48_MBIT1));
  }
  
  // Group Enable
  vf48_GrpEnable(myvme, VF48_BASE, ts.vf48.group_bitwise_all_0x3f_);
  printf("vf48: Group Enable :0x%x\n", vf48_GrpRead(myvme, VF48_BASE));
 
  // Start ACQ for VF48
  vf48_AcqStart(myvme, VF48_BASE);
#endif
 
 
#if defined VMEIO_CODE
  //-------- VMEIO (triumf board) ----------------------------------
  // Set am to A24 non-privileged Data
  mvme_set_am(myvme, MVME_AM_A24_ND);
 
  // Set dmode to D32
  mvme_set_dmode(myvme, MVME_DMODE_D32);
 
  // Set pulse mode
  vmeio_OutputSet(myvme, VMEIO_BASE, (P_BOE|P_EOE|P_CLR));
#endif
 
  //------ FINAL ACTIONS before BOR -----------
  // Send Clear pulse 
  //  vmeio_SyncWrite(myvme, VMEIO_BASE, P_CLR);
 
  /* Reset Latch */
 
  /********* commented out for other test purpose
  vmeio_SyncWrite(myvme, VMEIO_BASE, P_EOE);
  
  // Open run gate
  vmeio_AsyncWrite(myvme, VMEIO_BASE, S_RUNGATE);
  
  // Disable interrupt
  mvme_write_value(myvme, VLAM_BASE+4, 0x0);
  
  // Reset Latch
  mvme_write_value(myvme, VLAM_BASE, 0x1);
  
  // Clear pending interrupts
  mvme_write_value(myvme, VLAM_BASE+8, 0x0);
  //  printf("Vector:0x%lx\n", (mvme_read_value(myvme, VLAM_BASE+0x8) & 0xFF));
  
  // Enable interrupt
  inRun = 1;
  mvme_write_value(myvme, VLAM_BASE+4, inRun);
  */
  
  missed = 0; // for the v1729 missed trigger
  printf("End of BOR\n");
  return SUCCESS;
}

Here is the call graph for this function:

end_of_run()

INT end_of_run	(	INT	run_number,
		char *	error
	)

End of Run.

Called every stop run transition. Set equipment status in ODB, stop acquisition on the modules.

Parameters

[in]	run_number	Number of the run being ended
[out]	error	Can be used to write a message string to midas.log

Definition at line 574 of file fevmemodules.c.

{
  // Stop DAQ for seting up the parameters
  vf48_AcqStop(myvme, VF48_BASE);
    
  done = 0;
  stop_req = 0;
  inRun = 0;
  // Disable interrupt
  mvme_write_value(myvme, VLAM_BASE+4, inRun);
  trig_level = 0;
  // Close run gate
  vmeio_AsyncWrite(myvme, VMEIO_BASE, 0x0);
  return SUCCESS;
}

Here is the call graph for this function:

frontend_exit()

INT frontend_exit

(

void

)

Frontend exit.

Runs at frontend shutdown. Disconnect hardware and set equipment status in ODB

Returns

Midas status code

Definition at line 278 of file fevmemodules.c.

{
   return SUCCESS;
}

frontend_init()

INT frontend_init

(

void

)

Frontend initialization.

Runs once at application startup. We initialize the hardware and optical interfaces and set the equipment status in ODB. We also lock the frontend to once physical cpu core.

Returns

Midas status code

Definition at line 233 of file fevmemodules.c.

{
  int size, status;
  char set_str[80];
 
  /* Book Setting space */
  TRIGGER_SETTINGS_STR(trigger_settings_str);
 
  /* Map /equipment/Trigger/settings for the sequencer */
  sprintf(set_str, "/Equipment/Trigger/Settings");
  status = db_create_record(hDB, 0, set_str, strcomb1(trigger_settings_str).c_str());
  status = db_find_key (hDB, 0, set_str, &hSet);
  if (status != DB_SUCCESS)
    cm_msg(MINFO,"FE","Key %s not found", set_str);
  
  /* Enable hot-link on settings/ of the equipment */
  size = sizeof(TRIGGER_SETTINGS);
  if ((status = db_open_record(hDB, hSet, &ts, size, MODE_READ
                               , seq_callback, NULL)) != DB_SUCCESS)
    return status;
  
  // Open VME interface   
  status = mvme_open(&myvme, 0);
  
  // Set am to A24 non-privileged Data
  mvme_set_am(myvme, MVME_AM_A24_ND);
  
  // Set dmode to D32
  mvme_set_dmode(myvme, MVME_DMODE_D32);
 
#if defined V1729_CODE
  // Collect Pedestals
  v1729_PedestalRun(myvme, V1729_BASE, 10, 1);
  
  // Do vernier calibration
  v1729_TimeCalibrationRun(myvme, V1729_BASE, 1);
#endif
 
  /* print message and return FE_ERR_HW if frontend should not be started */
  
  return SUCCESS;
}

Here is the call graph for this function:

frontend_loop()

INT frontend_loop

(

void

)

Frontend loop.

If frontend_call_loop is true, this routine gets called when the frontend is idle or once between every event.

Returns

Midas status code

Definition at line 621 of file fevmemodules.c.

{
  /* if frontend_call_loop is true, this routine gets called when
     the frontend is idle or once between every event */
  char str[128];
 
  if (stop_req && done==0) {
    db_set_value(hDB,0,"/logger/channels/0/Settings/Event limit", &evlimit, sizeof(evlimit), 1, TID_DWORD); 
    if (cm_transition(TR_STOP, 0, str, sizeof(str), ASYNC, FALSE) != CM_SUCCESS) {
      cm_msg(MERROR, "VF48 Timeout", "cannot stop run: %s", str);
    }
    inRun = 0;
    // Disable interrupt
    mvme_write_value(myvme, VLAM_BASE+4, inRun);
    done = 1;
    cm_msg(MERROR, "VF48 Timeout","VF48 Stop requested");
  }
  return SUCCESS;
}

Here is the call graph for this function:

interrupt_configure()

INT interrupt_configure	(	INT	cmd,
		INT	source,
		PTYPE	adr
	)

Definition at line 671 of file fevmemodules.c.

{
  int vec = 0;
  switch (cmd) {
  case CMD_INTERRUPT_ENABLE:
    if (inRun) mvme_write_value(myvme, VLAM_BASE+4, 0x1);
    break;
  case CMD_INTERRUPT_DISABLE:
    if (inRun) mvme_write_value(myvme, VLAM_BASE+4, 0x0);
    break;
  case CMD_INTERRUPT_ATTACH:
    mvme_set_dmode(myvme, MVME_DMODE_D32);
    mvme_interrupt_attach(myvme, INT_LEVEL, INT_VECTOR, (void *)adr, &myinfo);
    mvme_write_value(myvme, VLAM_BASE+0x10, INT_VECTOR);
    vec = mvme_read_value(myvme, VLAM_BASE+0x10);
    printf("Interrupt Attached to 0x%x for vector:0x%x\n", adr, vec&0xFF);
    break;
  case CMD_INTERRUPT_DETACH:
    printf("Interrupt Detach\n");
    break;
  }
  return SUCCESS;
}

Here is the call graph for this function:

interrupt_routine()

void interrupt_routine ( void  )

extern

pause_run()

INT pause_run	(	INT	run_number,
		char *	error
	)

Pause Run.

Called every pause run transition.

Parameters

[in]	run_number	Number of the run being ended
[out]	error	Can be used to write a message string to midas.log

Returns

Midas status code

Definition at line 591 of file fevmemodules.c.

{
  inRun = 0;
  // Disable interrupt
  mvme_write_value(myvme, VLAM_BASE+4, inRun);
  trig_level = 0;
  // Close run gate
  vmeio_AsyncWrite(myvme, VMEIO_BASE, 0x0);
   
  return SUCCESS;
}

Here is the call graph for this function:

poll_event()

INT poll_event	(	INT	source,
		INT	count,
		BOOL	test
	)

Polling routine for events.

Parameters

[in]	source	Event source (LAM/IRQ)
[in]	count	Loop count for event polling timeout
[in]	test	flag used to time the polling

Returns

1 if event is available, 0 if done polling (no event). If test equals TRUE, don't return.

Definition at line 650 of file fevmemodules.c.

{
  int i;
  int lam = 0;
  
  for (i = 0; i < count; i++, lam++) {
    lam = vmeio_CsrRead(myvme, VMEIO_BASE);
    if (lam)
      if (!test)
   return lam;
  }
  
  return 0;
}

Here is the call graph for this function:

read_scaler_event()

INT read_scaler_event	(	char *	pevent,
		INT	off
	)

Scaler event readout.

Placeholder.

Scaler event readout routine. Not used in this example.

Parameters

[in]	pevent	Pointer to event buffer
[in]	off	Caller info (unused here), see mfe.c

Returns

Size of the event

Definition at line 841 of file fevmemodules.c.

{
  DWORD *pdata;
  
  /* init bank structure */
  bk_init(pevent);
  
  /* create SCLR bank */
  bk_create(pevent, "SCLR", TID_DWORD, &pdata);
  
  /* read scaler bank */
  bk_close(pevent, pdata);
  
  //   return bk_size(pevent);
  // Nothing to send for now
  return 0;
}

Here is the call graph for this function:

read_trigger_event()

INT read_trigger_event	(	char *	pevent,
		INT	off
	)

---

---

Definition at line 697 of file fevmemodules.c.

{
#if defined VADC0_CODE
  DWORD  *pdata;
#endif
#if defined VTDC0_CODE
  DWORD  *pdata;
#endif
#if defined VF48_CODE
  DWORD  *pdata;
  int status, evtlength;
#endif
#if defined V1729_CODE
  INT   *pidata, timeout;
  WORD   data[20000];
  INT    nch, npt, nentry;
#endif
 
  evlimit = SERIAL_NUMBER(pevent);
  // Timing Begin of Event
  //  vmeio_SyncWrite(myvme, VMEIO_BASE, P_BOE);
  // Open READOUT State
  //  vmeio_AsyncWrite(myvme, VMEIO_BASE, (S_READOUT|S_RUNGATE));
 
  // > THE LINE BELOW SHOULD BE HERE AND NOWHERE ELSE < !
  bk_init32(pevent);
 
#if defined VADC0_CODE
  /* create structured ADC0 bank */
  bk_create(pevent, "ADC0", TID_DWORD, &pdata);
  v792_EvtCntRead(myvme, VADC0_BASE, &evtcnt);
  /* Read Event */
  v792_EventRead(myvme, VADC0_BASE, pdata, &nentry);
  pdata += nentry;
  bk_close(pevent, pdata);
  v792_DataClear(myvme, VADC0_BASE);
#endif
 
#if defined VADC1_CODE
  /* create structured ADC1 bank */
  bk_create(pevent, "ADC1", TID_DWORD, &pdata);
  /* Read Event */
  v792_EventRead(myvme, VADC1_BASE, pdata, &nentry);
  pdata += nentry;
  bk_close(pevent, pdata);
  //    v792_EvtCntReset(myvme, VADC1_BASE);
#endif
 
#if defined VADC2_CODE
  /* create structured ADC2 bank */
  bk_create(pevent, "ADC2", TID_DWORD, &pdata);
  /* Read Event */
  v792_EventRead(myvme, VADC2_BASE, pdata, &nentry);
  pdata += nentry;
  bk_close(pevent, pdata);
#endif
 
#if defined VADC3_CODE
  /* create structured ADC3 bank */
  bk_create(pevent, "ADC3", TID_DWORD, &pdata);
  /* Read Event */
  v792_EventRead(myvme, VADC3_BASE, pdata, &nentry);
  pdata += nentry;
  bk_close(pevent, pdata);
#endif
 
#if defined VTDC0_CODE
  /* create variable length TDC bank */
  bk_create(pevent, "TDC0", TID_DWORD, &pdata);
  /* Read Event */
  v1190_EventRead(myvme, VTDC0_BASE, pdata, &nentry);
  pdata += nentry;
  /* clear TDC */
  //  v1190_SoftClear(myvme, VTDC0_BASE);
  bk_close(pevent, pdata);
#endif
 
#if defined VF48_CODE
  /* create variable length WAVE bank */
  bk_create(pevent, "WAVE", TID_DWORD, &pdata);
  status = vf48_EventRead64(myvme, VF48_BASE, pdata, &evtlength);
  //  printf("read vf48 evtlength:%d\n", evtlength);
  pdata += (DWORD) evtlength;
  bk_close(pevent, pdata);
#endif
 
#if defined V1729_CODE
  timeout=20;
  while(!v1729_isTrigger(myvme, V1729_BASE) && timeout) {
    timeout--;
    ss_sleep(1);
  };
  if (timeout == 0) {
    printf("No Trigger evt#:%d missed:%d (%6.2f%%)\n", SERIAL_NUMBER(pevent)
      , ++missed
      , 100.*((float)missed/(float)SERIAL_NUMBER(pevent)));
  }
  npt = 2560;
  nch =    4;
  v1729_DataRead(myvme, V1729_BASE, data, nch, npt);
  bk_create(pevent, "FWAV", TID_INT, &pidata);
  *pidata++ = npt; 
  *pidata++ = data[7];
  v1729_OrderData(myvme, V1729_BASE, data, pidata, nch, 0, npt);
  pidata += npt;
  /*
   *pidata++ = 0x10000 | npt;
   v1729_OrderData(myvme, V1729_BASE, data, pidata, nch, 1, npt);
   pidata += npt;
  */
  bk_close(pevent, pidata);
  
  // Start acquisition
  v1729_AcqStart(myvme, V1729_BASE);
#endif
 
  // EOB  
  /*
    vmeio_AsyncWrite(myvme, VMEIO_BASE, S_RUNGATE);
    vmeio_SyncWrite(myvme, VMEIO_BASE, P_EOE);
    
    // Reset Latch EOB
    mvme_write_value(myvme, VLAM_BASE, 0x0);  // Nim out 
  */
  
  if (evtlength) {
    //    printf("evtlength: %d  bk_size:%d\n", evtlength, bk_size(pevent));
    return bk_size(pevent);
  }
  else
    return 0;
}

Here is the call graph for this function:

register_cnaf_callback()

void register_cnaf_callback

(

int

debug

)

Definition at line 122 of file cnaf_callback.cxx.

                                       {
   cnaf_debug = debug;
   /* register CNAF callback */
   cm_register_function(RPC_CNAF16, cnaf_callback);
   cm_register_function(RPC_CNAF24, cnaf_callback);
}

Here is the call graph for this function:

resume_run()

INT resume_run	(	INT	run_number,
		char *	error
	)

Resume Run.

Called every resume run transition.

Parameters

[in]	run_number	Number of the run being ended
[out]	error	Can be used to write a message string to midas.log

Returns

Midas status code

Definition at line 604 of file fevmemodules.c.

{
  trig_level = TRIG_LEVEL;
 
  // EOB Pulse
  vmeio_SyncWrite(myvme, VMEIO_BASE, P_EOE);
 
  // Open run gate
  vmeio_AsyncWrite(myvme, VMEIO_BASE, S_RUNGATE);
 
  // Enable interrupt
  inRun = 1;
  mvme_write_value(myvme, VLAM_BASE+4, inRun);
  return SUCCESS;
}

Here is the call graph for this function:

seq_callback()

void seq_callback	(	INT	hDB,
		INT	hseq,
		void *	info
	)

Definition at line 227 of file fevmemodules.c.

{
  printf("odb ... trigger settings touched\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

display_period

INT display_period = 000

a frontend status page is displayed with this frequency in ms

Definition at line 66 of file fevmemodules.c.

done

int done =0

Definition at line 82 of file fevmemodules.c.

equipment

EQUIPMENT equipment[]

Main structure for midas equipment.

Definition at line 150 of file fevmemodules.c.

                        {
 
   {"Trigger",               /* equipment name */
    {1, 0,                   /* event ID, trigger mask */
     "SYSTEM",               /* event buffer */
#ifdef USE_INT
     EQ_INTERRUPT,           /* equipment type */
#else
     EQ_PERIODIC, // POLLED,              /* equipment type */
#endif
     LAM_SOURCE(0, 0x0),     /* event source crate 0, all stations */
     "MIDAS",                /* format */
     TRUE,                   /* enabled */
     RO_RUNNING,          /* read only when running */
     500,                    /* poll for 500ms */
     0,                      /* stop run after this event limit */
     0,                      /* number of sub events */
     0,                      /* don't log history */
     "", "", "",},
    read_trigger_event,      /* readout routine */
    NULL, NULL,
    trigger_bank_list,
    }
   ,
 
   {"Scaler",                /* equipment name */
    {2, 0,                   /* event ID, trigger mask */
     "SYSTEM",               /* event buffer */
     EQ_PERIODIC ,           /* equipment type */
     0,                      /* event source */
     "MIDAS",                /* format */
     FALSE,                   /* enabled */
     RO_RUNNING | RO_TRANSITIONS |   /* read when running and on transitions */
     RO_ODB,                 /* and update ODB */
     10000,                  /* read every 10 sec */
     0,                      /* stop run after this event limit */
     0,                      /* number of sub events */
     0,                      /* log history */
     "", "", "",},
    read_scaler_event,       /* readout routine */
    },
 
   {""}
};

event_buffer_size

INT event_buffer_size = 10 * 100000

buffer size to hold events

Definition at line 75 of file fevmemodules.c.

evlimit

DWORD evlimit

Definition at line 83 of file fevmemodules.c.

frontend_call_loop

BOOL frontend_call_loop = FALSE

frontend_loop is called periodically if this variable is TRUE

Definition at line 63 of file fevmemodules.c.

frontend_file_name

char* frontend_file_name = __FILE__

The frontend file name, don't change it.

Definition at line 60 of file fevmemodules.c.

frontend_name

char* frontend_name = "fevmemodules"

The frontend name (client name) as seen by other MIDAS clients.

Definition at line 58 of file fevmemodules.c.

hDB

HNDLE hDB

extern

main ODB handle

Definition at line 207 of file mana.cxx.

hSet

HNDLE hSet

Definition at line 101 of file fevmemodules.c.

inRun

int inRun = 0

Definition at line 81 of file fevmemodules.c.

int_info

INT_INFO int_info

extern

intflag

int intflag = 0

Definition at line 80 of file fevmemodules.c.

max_event_size

INT max_event_size = 200000

maximum event size produced by this frontend

Definition at line 69 of file fevmemodules.c.

max_event_size_frag

INT max_event_size_frag = 5 * 1024 * 1024

maximum event size for fragmented events (EQ_FRAGMENTED)

Definition at line 72 of file fevmemodules.c.

missed

int missed =0

Definition at line 81 of file fevmemodules.c.

myinfo

int myinfo = VME_INTERRUPT_SIGEVENT

Definition at line 48 of file fevmemodules.c.

myvme

MVME_INTERFACE* myvme

Definition at line 78 of file fevmemodules.c.

sRG

int sRG = 0

Definition at line 79 of file fevmemodules.c.

stop_req

int stop_req =0

Definition at line 82 of file fevmemodules.c.

trig_level

int trig_level = 0

Definition at line 43 of file fevmemodules.c.

trigger_bank_list

BANK_LIST trigger_bank_list[]

Initial value:

= {
 
   
   {"ADC0", TID_DWORD, N_ADC, NULL}
   ,
   {"ADC1", TID_DWORD, N_ADC, NULL}
   ,
   {"ADC2", TID_DWORD, N_ADC, NULL}
   ,
   {"ADC3", TID_DWORD, N_ADC, NULL}
   ,
   {"TDC0", TID_DWORD, N_TDC, NULL}
   ,
 
   {"WAVE", TID_DWORD, N_TDC, NULL}
   ,
   {"FWAV", TID_DWORD, N_PTS, NULL}
   ,
 
   {""}
   ,
}

Definition at line 123 of file fevmemodules.c.

                                {
 
   /* online banks */
   {"ADC0", TID_DWORD, N_ADC, NULL}
   ,
   {"ADC1", TID_DWORD, N_ADC, NULL}
   ,
   {"ADC2", TID_DWORD, N_ADC, NULL}
   ,
   {"ADC3", TID_DWORD, N_ADC, NULL}
   ,
   {"TDC0", TID_DWORD, N_TDC, NULL}
   ,
 
   {"WAVE", TID_DWORD, N_TDC, NULL}
   ,
   {"FWAV", TID_DWORD, N_PTS, NULL}
   ,
 
   {""}
   ,
};

ts

TRIGGER_SETTINGS ts

Definition at line 102 of file fevmemodules.c.

V1729_BASE

DWORD V1729_BASE = 0x120000

Definition at line 95 of file fevmemodules.c.

VADC0_BASE

DWORD VADC0_BASE = 0x100000

Definition at line 88 of file fevmemodules.c.

VADC1_BASE

DWORD VADC1_BASE = 0x200000

Definition at line 89 of file fevmemodules.c.

VADC2_BASE

DWORD VADC2_BASE = 0x300000

Definition at line 90 of file fevmemodules.c.

VADC3_BASE

DWORD VADC3_BASE = 0x400000

Definition at line 91 of file fevmemodules.c.

VF48_BASE

DWORD VF48_BASE = 0xAF0000

Definition at line 94 of file fevmemodules.c.

vf48_error

int vf48_error = 0

Definition at line 696 of file fevmemodules.c.

VLAM_BASE

DWORD VLAM_BASE = 0x800000

Definition at line 93 of file fevmemodules.c.

VMEIO_BASE

DWORD VMEIO_BASE = 0x780000

Definition at line 86 of file fevmemodules.c.

VTDC0_BASE

DWORD VTDC0_BASE = 0xF10000

Definition at line 87 of file fevmemodules.c.