feccusb.cxx File Reference

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include <string.h>
#include "midas.h"
#include <libxxusb.h>
#include "ccusb.h"
#include "OdbCCusb.h"

Include dependency graph for feccusb.cxx:

Go to the source code of this file.

Macros
#define	N_ADC8   12
#define	SLOT_ADC8   10

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.
INT	read_trigger_event (char *pevent, INT off)
	Event readout.
INT	read_scaler_event (char *pevent, INT off)
	Scaler event readout.
INT	poll_event (INT source, INT count, BOOL test)
INT	interrupt_configure (INT cmd, INT source, POINTER_T adr)
void	seq_callback (INT hDB, INT hseq, void *info)
int	ccUsbFlush (void)
BOOL	clear_buffer_events (int transition, BOOL first)

Variables
char const *	frontend_name = "feccusb"
char const *	frontend_file_name = __FILE__
BOOL	frontend_call_loop = FALSE
INT	display_period = 000
INT	max_event_size = 10000
INT	max_event_size_frag = 5 * 1024 * 1024
INT	event_buffer_size = 100 * 10000
xxusb_device_type	devices [10]
struct usb_device *	dev
usb_dev_handle *	udev
HNDLE	hDB
	main ODB handle
HNDLE	hSetCC
	Midas equipment/<name>/Settings info handles.
CCUSB_SETTINGS	tscc
	Settings local structure (see OdbCCusb.h)
EQUIPMENT	equipment []
BOOL	in_deferred_transition = FALSE
BOOL	finished_clearing_buffer = FALSE
int	number_extra_reads = 0
int	EventsInRun = 0

Macro Definition Documentation

N_ADC8

#define N_ADC8   12

Definition at line 66 of file feccusb.cxx.

SLOT_ADC8

#define SLOT_ADC8   10

Definition at line 74 of file feccusb.cxx.

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 314 of file feccusb.cxx.

                                              {
 
  //
  // Construct the CAMAC list to be loaded into the Stack
  long int stack[100];
  int i, ret;
  int q, x;
  long d24;
  short d16;
 
  // Create the CAMAC list to be performed on each LAM
  StackCreate(stack);
 
  // StackXxx(), MRAD16, WMARKER, etc and macros are defined in 
  // in ccusb.h
  //                   n       a   f  data  
  StackFill(MRAD16 , SLOT_ADC8, 0 , 0, 12, stack);// read 12 ADC8 
  // StackFill(MRAD16 , SLOT_ADCD, 0 , 0, 12, stack);// read 12 ADCD 
  //  StackFill(MRAD16 , SLOT_TDC, 0 , 0, 7, stack); // read  8 TDC
  // Use of F2 can prevent the F9 if last readout is last A  
  //StackFill(CD16   , SLOT_TDC, 0 , 9, 0, stack); // clear TDC, data is ignored (command)  
  StackFill(CD16   , SLOT_ADC8, 0 , 9, 0, stack); // clear ADC8
  // StackFill(CD16   , SLOT_ADCD, 0 , 9, 0, stack); // clear ADCD
  StackFill(WMARKER, 0, 0, 0, 0xFEED, stack);    // Our marker 0xfeed
  StackClose(stack);
 
  #if 1
  // Debugging Check stack before writing
  printf("stack[0]:%ld\n", stack[0]);
  for (i = 0; i < stack[0]+1; i++) {
    printf("stack[%i]=0x%lx\n", i, stack[i]);
  }
 
  // Load stack into CC-USB
  ret = xxusb_stack_write(udev, 2, stack);
  ret -= 2;
  if (ret<0) {
    printf("err on stack_write:%d\n", ret);
  } else {
    printf("Nbytes(ret) from stack_write:%d\n", ret);
    for (i = 0; i < (ret/2); i++) {
      if(0) printf("Wstack[%i]=0x%lx\n", i, stack[i]);
    }
  }
  #endif
 
  // Debugging Read stack 
  ret = xxusb_stack_read(udev, 2, stack);
  if (ret<0) {
    printf("err on stack_read:%d\n", ret);
  } else {
    printf("Nbytes(ret) from stack_read:%d\n", ret);
    for (i = 0; i < (ret/2); i++) {
      if(0) printf("Rstack[%i]=0x%lx\n", i, stack[i]);
    }
  }
  
  // Remove Inhibit
  CAMAC_I(udev, FALSE);
  
  // LAM mask from the Equipment
  ret = CAMAC_write(udev, 25, 9, 16, LAM_SOURCE_STATION(equipment[0].info.source), &q, &x);
 
  // delay LAM timeout[15..8], trigger delay[7..0]
  d16 = ((tscc.lam_timeout & 0xFF) << 8) | (tscc.trig_delay & 0xFF);
  printf ("lam, trigger delay : 0x%x\n", d16);
  ret = CAMAC_write(udev, 25, 2, 16, d16, &q, &x);
 
  //  Enable LAM
  // ret = CAMAC_read(udev, SLOT_TDC, 0, 26, &d24, &q, &x);
  ret = CAMAC_read(udev, SLOT_ADC8, 0, 26, &d24, &q, &x);
  //ret = CAMAC_read(udev, SLOT_ADCD, 0, 26, &d24, &q, &x);
  // printf("ret:%d q:%d x:%d\n", ret, q, x);
 
  // Opt in Global Mode register N(25) A(1) F(16)    
  // Buffer size 
  // 0:4096, 1:2048, 2:1024, 3:512, 4:256, 5:128, 6:64, 7:single event
  ret = CAMAC_write(udev, 25, 1, 16, tscc.buffer_size, &q, &x);
 
  // CAMAC_DGG creates a gate pulse with control of delay, width 
  // in 10ns increments. 
  // BUT range is limited to 16bit anyway annd only GG-A (0) provides
  // the delay extension.
  // Maximum delay 1e6 -> minimum frq 1KHz 
  //                DGG_A Pulser NimO1               invert latch
  ret = CAMAC_DGG(udev, 0,     7,    1, tscc.delay/10, tscc.width/10,     0,    0); 
 
  //  First clear before first LAM/readout
  ret = CAMAC_read(udev, SLOT_ADC8, 0, 9, &d24, &q, &x);
  // ret = CAMAC_read(udev, SLOT_ADCD, 0, 9, &d24, &q, &x);
  // ret = CAMAC_read(udev, SLOT_TDC, 0, 9, &d24, &q, &x);
 
  //  Start DAQ mode
  ret = xxusb_register_write(udev, 1, 0x1);
  //
  // NO CAMAC calls ALLOWED beyond this point!!!!!!!!
  //  as the Module is in acquisition mode now
  //
 
  // Count total events in run.
  EventsInRun = 0;
  // Set value for deferred transition (to readout last events).
  in_deferred_transition = FALSE;
  finished_clearing_buffer = FALSE;
 
  return SUCCESS;
}

Here is the call graph for this function:

ccUsbFlush()

int ccUsbFlush

(

void

)

Definition at line 165 of file feccusb.cxx.

                     {
  short IntArray [10000];  //for FIFOREAD
  
  int ret=1;
  int k=0;
  while(ret>0) {
    ret = xxusb_bulk_read(udev, IntArray, 8192, 100);
    if(ret>0) {
      printf("drain loops: %i (result %i)\n ",k,ret);                                     
      k++;
      if (k>100) ret=0;
 
      // Last event dump
      for(int i =0; i < ret/2; i++){
   printf("%x ",IntArray[i] & 0xffff);
   if(i%8==7) printf("\n");
      }
    }
  }
  printf("\n");
  printf("First bin %x\n",IntArray[0]);
  return (IntArray[0] & 0xfff);
 
}

Here is the caller graph for this function:

clear_buffer_events()

BOOL clear_buffer_events	(	int	transition,
		BOOL	first
	)

Definition at line 196 of file feccusb.cxx.

                                                    {
 
  if(first){
 
    //  Stop DAQ mode
    int ret = xxusb_register_write(udev, 1, 0x0);
    printf("stopping CAMAC xxusb_register_write=%d\n", ret);
 
    finished_clearing_buffer = FALSE;
    in_deferred_transition = TRUE;
    number_extra_reads = 0;
    printf("Starting deferred to clear USB buffer\n");
  }
 
  if(finished_clearing_buffer){
    printf("Finished deferred transition after %i extra reads.\n",number_extra_reads);
    return TRUE;
  }
 
  if(number_extra_reads > 10){
    cm_msg(MERROR, "clear_buffer_events", "Didn't manage to clear CCUSB buffer after 10 extra reads.\n");
    return TRUE;
  }
 
  return FALSE;
}

Here is the call graph for this function:

Here is the caller 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 423 of file feccusb.cxx.

{
  //  Stop DAQ mode
  int ret = xxusb_register_write(udev, 1, 0x0);
  printf("End of run Stop DAQ return:%d\n", ret);
 
  // Set Inhibit
  //  CAMAC_I(udev, TRUE);
 
  // Flush data.
  // This shouldn't do anything, since we flushed all the events with deferred transition.
  ret = ccUsbFlush();
  if(ret > 0) cm_msg(MINFO, "ccusb", "Flushed %d events; surprising", ret);
  EventsInRun += ret;
  cm_msg(MINFO, "ccusb", "Total number of events read in this run: %i \n",EventsInRun);
  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 302 of file feccusb.cxx.

{
  // Close device
  xxusb_device_close(udev);
  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 226 of file feccusb.cxx.

                    {
 
  int size, status;
  char set_str[80];
  CCUSB_SETTINGS_STR(ccusb_settings_str);
 
  cm_get_experiment_database(&hDB, &status);
  
  // Map /equipment/<eq_name>/settings 
  sprintf(set_str, "/Equipment/CCUSB/Settings");
  
  // create the ODB Settings if not existing under Equipment/<eqname>/
  // If already existing, don't change anything 
  status = db_create_record(hDB, 0, set_str, strcomb1(ccusb_settings_str).c_str());
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "ccusb", "cannot create record (%s)", set_str);
    return FE_ERR_ODB;
  }
  
  // Get the equipment/<eqname>/Settings key
  status = db_find_key(hDB, 0, set_str, &hSetCC);
  
  // Enable hot-link on /Settings of the equipment
  // Anything changed under /Settings will be triggering the callback (above)
  size = sizeof(CCUSB_SETTINGS);
  if ((status = db_open_record(hDB, hSetCC, &tscc, size, MODE_READ
                , seq_callback, NULL)) != DB_SUCCESS) {
    cm_msg(MERROR, "ccusb", "cannot open record (%s)", set_str);
    return CM_DB_ERROR;
  }
 
  // Setup a deferred transition so that we can read out any events that remain in
  // buffer at the end of the run.
  cm_register_deferred_transition(TR_STOP,clear_buffer_events);
 
  // hardware initialization   
  //Find XX_USB devices and open the first one found
  printf("Initializing USB device\n");
  int ret = xxusb_devices_find(devices);
  printf("Testing first USB device; ret=%i\n",ret);
  dev = devices[0].usbdev;
  udev = xxusb_device_open(dev);
 
  // Make sure CC_USB opened OK
  if(!udev) {
    cm_msg(MERROR, "ccusb", "Failed to Open CC_USB");
    return FE_ERR_HW;
  } 
 
  //  Stop DAQ mode in case it was left running (after crash)
  ret = xxusb_register_write(udev, 1, 0x0);
 
  if(ret < 0){
    cm_msg(MERROR, "ccusb", "Error writing to CCUSB; error message = %i",ret);
    return FE_ERR_HW;
  }
 
  //  printf("stop DAQ return:%d\n", ret);
 
  // Flush old data first
  ccUsbFlush();
  //  printf("Flush return:%d\n", ret);
 
  // CAMAC CLEAR
  CAMAC_C(udev);
  // printf("CAMAC_C return:%d\n", ret);
  // CAMAC Z
  CAMAC_Z(udev);
  // printf("CAMAC_Z return:%d\n", ret);
  
  /* print message and return FE_ERR_HW if frontend should not be started */
  cm_msg(MINFO, "ccusb", "CC-USB ready");
  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 478 of file feccusb.cxx.

{
   /* if frontend_call_loop is true, this routine gets called when
      the frontend is idle or once between every event */
   return SUCCESS;
}

interrupt_configure()

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

Definition at line 513 of file feccusb.cxx.

{
   switch (cmd) {
   case CMD_INTERRUPT_ENABLE:
      break;
   case CMD_INTERRUPT_DISABLE:
      break;
   case CMD_INTERRUPT_ATTACH:
      break;
   case CMD_INTERRUPT_DETACH:
      break;
   }
   return SUCCESS;
}

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 442 of file feccusb.cxx.

{
  //  Stop DAQ mode
  xxusb_register_write(udev, 1, 0x0);
 
  // Set Inhibit
  CAMAC_I(udev, TRUE);
 
  // -PAA-
  // flush data, these data are lost as the run is already closed.
  // will implement deferred transition later to fix this issue
  ccUsbFlush();
   return SUCCESS;
}

Here is the call graph for this function:

poll_event()

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

Definition at line 494 of file feccusb.cxx.

{
   int i;
   DWORD lam=0;
 
   for (i = 0; i < count; i++) {
     ss_sleep(100);
     if (lam & LAM_SOURCE_STATION(source))
       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.

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 295 of file ebfe.cxx.

{
   DWORD *pdata, a;
 
   /* init bank structure */
   bk_init(pevent);
 
   /* create SCLR bank */
   bk_create(pevent, Sclx, TID_DWORD, (void**)&pdata);
 
   /* read scaler bank */
   for (a = 0; a < N_SCLR; a++)
      cam24i(CRATE, SLOT_SCLR, a, 0, pdata++);
 
   bk_close(pevent, pdata);
 
   return bk_size(pevent);
}

Here is the call graph for this function:

read_trigger_event()

INT read_trigger_event	(	char *	pevent,
		INT	off
	)

Event readout.

Trigger event readout.

Event readout routine. This is called by the polling or interrupt routines. (see mfe.c). For each module, read the event buffer into a midas data bank. If ZLE data exists, create another bank for it. Finally, create a statistical bank for data throughput analysis.

Parameters

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

Returns

Size of the event

Main trigger event readout routine. This is called by the polling or interrupt routines. (see mfe.c). For each module, read the event buffer into a midas data bank.

Parameters

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

Returns

Size of the event

---

---

Definition at line 529 of file feccusb.cxx.

{
  WORD *pdata;
  int ret, nd16=0;
  
  if(in_deferred_transition){
    number_extra_reads++;
  }
 
  /* init bank structure */
  bk_init(pevent);
  
    /* create Midas bank named ADC8 for ADC card in slot 8*/
  bk_create(pevent, "ADC8", TID_WORD, (void **)&pdata);
 
 /* create Midas bank named ADCD D=13 for ADC card in slot 13*/
  //bk_create(pevent, "ADCD", TID_WORD, (void **)&pdata);
 
 /* create Midas bank named ADTD */
//  bk_create(pevent, "ADTD", TID_WORD, (void **)&pdata);
 
  // Read CC-USB buffer, returns nbytes, use for 32-bit data
  ret = xxusb_bulk_read(udev, pdata, 8192, 500);  
  if (ret > 0) {
    nd16 = ret / 2;                 // # of d16
    int nevents = (pdata[0]& 0xfff);   // # of LAM in the buffer
    EventsInRun += nevents;
 #if 0
    int evtsize = (pdata[1] & 0xffff);  // # of words per event
    printf("Read data: ret:%d  nd16:%d nevent:%d, evtsize:%d\n", ret, nd16, nevents, evtsize);
#endif
 
    //    if (nevents & 0x8000) return 0;  // Skip event
    if(pdata[0] & 0x8000)cm_msg(MINFO, "read_trigger_event", "Readout last CAMAC event in run.");
      
    
    if (nd16 > 0) {
      // Adjust pointer (include nevents, evtsize)
      pdata += nd16;
    }
 
    // Close bank
    bk_close(pevent, pdata);
 
    printf("readout non-zero bytes from CAMAC usb\n");
    // Done with a valid event
    return bk_size(pevent); 
 
 } else {
    //    printf("no read ret:%d\n", ret);
 
    // we finished the deferred transition when we do a read of USB buffer 
    // and don't get any extra data.
    if(in_deferred_transition){      
      finished_clearing_buffer = TRUE; 
    }
    return 0;
  }
}

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 458 of file feccusb.cxx.

{
  int q, x;
  long d24;
 
  //  Clear module
  CAMAC_read(udev, SLOT_ADC8, 0, 9, &d24, &q, &x);
  //CAMAC_read(udev, SLOT_ADCD, 0, 9, &d24, &q, &x);
  // CAMAC_read(udev, SLOT_TDC, 0, 9, &d24, &q, &x);
 
  // Remove Inhibit
  CAMAC_I(udev, FALSE);
 
  //  Start DAQ mode
  xxusb_register_write(udev, 1, 0x1);
 
  return SUCCESS;
}

Here is the call graph for this function:

seq_callback()

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

Definition at line 155 of file feccusb.cxx.

{
  KEY key;
  db_get_key(hDB, hseq, &key);
  printf("odb ... %s touched (%d)\n", key.name, hseq);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

dev

struct usb_device* dev

Definition at line 80 of file feccusb.cxx.

devices

xxusb_device_type devices[10]

Definition at line 79 of file feccusb.cxx.

display_period

INT display_period = 000

Definition at line 53 of file feccusb.cxx.

equipment

EQUIPMENT equipment[]

Initial value:

= {
 
   {"CCUSB",               
    {1, 0,                   
     "BUF8",               
     EQ_PERIODIC,            
     LAM_SOURCE(0, 0xFFFFFF),
     "MIDAS",                
     TRUE,                   
     RO_RUNNING,             
     10,                     
     0,                      
     0,                      
     0,                      
     "", "", "",},
    read_trigger_event,      
    },
 
   {""}
}

Definition at line 103 of file feccusb.cxx.

                        {
 
   {"CCUSB",               /* equipment name */
    {1, 0,                   /* event ID, trigger mask */
     "BUF8",               /* event buffer */
     EQ_PERIODIC,            /* equipment type */
     LAM_SOURCE(0, 0xFFFFFF),/* event source crate 0, all stations */
     "MIDAS",                /* format */
     TRUE,                   /* enabled */
     RO_RUNNING,             /* read only when running */
     10,                     /* poll for 10ms */
     0,                      /* stop run after this event limit */
     0,                      /* number of sub events */
     0,                      /* don't log history */
     "", "", "",},
    read_trigger_event,      /* readout routine */
    },
 
   {""}
};

event_buffer_size

INT event_buffer_size = 100 * 10000

Definition at line 62 of file feccusb.cxx.

EventsInRun

int EventsInRun = 0

Definition at line 310 of file feccusb.cxx.

finished_clearing_buffer

BOOL finished_clearing_buffer = FALSE

Definition at line 191 of file feccusb.cxx.

frontend_call_loop

BOOL frontend_call_loop = FALSE

Definition at line 50 of file feccusb.cxx.

frontend_file_name

char const* frontend_file_name = __FILE__

Definition at line 47 of file feccusb.cxx.

frontend_name

char const* frontend_name = "feccusb"

Definition at line 45 of file feccusb.cxx.

hDB

HNDLE hDB

main ODB handle

Definition at line 83 of file feccusb.cxx.

hSetCC

HNDLE hSetCC

Midas equipment/<name>/Settings info handles.

Definition at line 83 of file feccusb.cxx.

in_deferred_transition

BOOL in_deferred_transition = FALSE

Definition at line 190 of file feccusb.cxx.

max_event_size

INT max_event_size = 10000

Definition at line 56 of file feccusb.cxx.

max_event_size_frag

INT max_event_size_frag = 5 * 1024 * 1024

Definition at line 59 of file feccusb.cxx.

number_extra_reads

int number_extra_reads = 0

Definition at line 192 of file feccusb.cxx.

tscc

CCUSB_SETTINGS tscc

Settings local structure (see OdbCCusb.h)

Definition at line 84 of file feccusb.cxx.

udev

usb_dev_handle* udev

Definition at line 81 of file feccusb.cxx.