feserial.c

Go to the documentation of this file.

/********************************************************************\
 
  Name:         feserial.c
  Created by:
  Contents:     Experiment specific readout code (user part) of
                Midas frontend. This example simulates a "trigger
                event" and a "scaler event" which are filled with
                CAMAC or random data. The trigger event is filled
                with two banks (ADC0 and TDC0), the scaler event
                with one bank (SCLR).
 
  $Id$
\********************************************************************/
 
#include <stdio.h>
#include <stdlib.h>
#include "midas.h"
#include "rs232.h"
#include "experim.h"
 
/* make frontend functions callable from the C framework */
#ifdef __cplusplus
extern "C" {
#endif
 
/*-- Globals -------------------------------------------------------*/
 
/* The frontend name (client name) as seen by other MIDAS clients   */
char *frontend_name = "feSerial";
/* The frontend file name, don't change it */
char *frontend_file_name = __FILE__;
 
/* frontend_loop is called periodically if this variable is TRUE    */
BOOL frontend_call_loop = FALSE;
 
/* a frontend status page is displayed with this frequency in ms */
INT display_period = 3000;
 
/* maximum event size produced by this frontend */
INT max_event_size = 10000;
 
/* maximum event size for fragmented events (EQ_FRAGMENTED) */
INT max_event_size_frag = 5 * 1024 * 1024;
 
/* buffer size to hold events */
INT event_buffer_size = 10 * 10000;
 void **info;
char  strin[256];
HNDLE hDB, hSet;
/*-- Function declarations -----------------------------------------*/
 
INT frontend_init();
INT frontend_exit();
INT begin_of_run(INT run_number, char *error);
INT end_of_run(INT run_number, char *error);
INT pause_run(INT run_number, char *error);
INT resume_run(INT run_number, char *error);
INT frontend_loop();
 
INT read_trigger_event(char *pevent, INT off);
INT read_scaler_event(char *pevent, INT off);
 
 
/*-- Equipment list ------------------------------------------------*/
 
#undef USE_INT
 
EQUIPMENT equipment[] = {
 
   {"Trigger",               /* equipment name */
    {1, 0,                   /* event ID, trigger mask */
     "SYSTEM",               /* event buffer */
#ifdef USE_INT
     EQ_INTERRUPT,           /* equipment type */
#else
     EQ_PERIODIC,              /* equipment type */
#endif
     LAM_SOURCE(0, 0xFFFFFF),        /* event source crate 0, all stations */
     "MIDAS",                /* format */
     TRUE,                   /* enabled */
     RO_RUNNING |            /* read only when running */
     RO_ODB,                 /* and update ODB */
     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 */
    },
 
   {""}
};
 
#ifdef __cplusplus
}
#endif
 
/********************************************************************\
              Callback routines for system transitions
 
  These routines are called whenever a system transition like start/
  stop of a run occurs. The routines are called on the following
  occations:
 
  frontend_init:  When the frontend program is started. This routine
                  should initialize the hardware.
 
  frontend_exit:  When the frontend program is shut down. Can be used
                  to releas any locked resources like memory, commu-
                  nications ports etc.
 
  begin_of_run:   When a new run is started. Clear scalers, open
                  rungates, etc.
 
  end_of_run:     Called on a request to stop a run. Can send
                  end-of-run event and close run gates.
 
  pause_run:      When a run is paused. Should disable trigger events.
 
  resume_run:     When a run is resumed. Should enable trigger events.
\********************************************************************/
 
/*-- Frontend Init -------------------------------------------------*/
 
INT frontend_init()
{
   /* hardware initialization */
  INT 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);
 
 
    rs232(CMD_INIT, hSet, &info);
   /* print message and return FE_ERR_HW if frontend should not be started */
 
   return SUCCESS;
}
 
/*-- Frontend Exit -------------------------------------------------*/
 
INT frontend_exit()
{
   rs232(CMD_EXIT, info);
   return SUCCESS;
}
 
/*-- Begin of Run --------------------------------------------------*/
 
INT begin_of_run(INT run_number, char *error)
{
   /* put here clear scalers etc. */
   rs232(CMD_READ, info, strin, 256, 100);
   return SUCCESS;
}
 
/*-- End of Run ----------------------------------------------------*/
 
INT end_of_run(INT run_number, char *error)
{
   return SUCCESS;
}
 
/*-- Pause Run -----------------------------------------------------*/
 
INT pause_run(INT run_number, char *error)
{
   return SUCCESS;
}
 
/*-- Resuem Run ----------------------------------------------------*/
 
INT resume_run(INT run_number, char *error)
{
   return SUCCESS;
}
 
/*-- Frontend Loop -------------------------------------------------*/
 
INT frontend_loop()
{
   /* if frontend_call_loop is true, this routine gets called when
      the frontend is idle or once between every event */
   return SUCCESS;
}
 
/*------------------------------------------------------------------*/
 
/********************************************************************\
 
  Readout routines for different events
 
\********************************************************************/
 
/*-- Trigger event routines ----------------------------------------*/
 
INT poll_event(INT source, INT count, BOOL test)
/* Polling routine for events. Returns TRUE if event
   is available. If test equals TRUE, don't return. The test
   flag is used to time the polling */
{
   int i;
 
   for (i = 0; i < count; i++) {
//      cam_lam_read(LAM_SOURCE_CRATE(source), &lam);
 
//      if (lam & LAM_SOURCE_STATION(source))
         if (!test)
            return 1;
   }
 
   return 0;
}
 
/*-- Interrupt configuration ---------------------------------------*/
 
INT interrupt_configure(INT cmd, INT source, POINTER_T adr)
{
   switch (cmd) {
   case CMD_INTERRUPT_ENABLE:
      break;
   case CMD_INTERRUPT_DISABLE:
      break;
   case CMD_INTERRUPT_ATTACH:
      break;
   case CMD_INTERRUPT_DETACH:
      break;
   }
   return SUCCESS;
}
 
/*-- Event readout -------------------------------------------------*/
 
INT read_trigger_event(char *pevent, INT off)
{
   WORD *pdata, a;
   INT j;
 
   /* init bank structure */
   bk_init(pevent);
 
   /* create structured ADC0 bank */
   bk_create(pevent, "ADC0", TID_WORD, &pdata);
   /* Use following code to "simulate" data */
   for (a = 0; a < 3; a++)
      *pdata++ = rand() % 1024;
   rs232(CMD_GETS, info, strin, 256, 0, 500);
   for (j=0;j<256;j++) {
    if (strin[j] != 0)
      *pdata++ = strin[j];
   }
 
   bk_close(pevent, pdata);
 
   /* create variable length TDC bank */
   bk_create(pevent, "TDC0", TID_WORD, &pdata);
   /* Use following code to "simulate" data */
   for (a = 0; a < 3; a++)
      *pdata++ = rand() % 1024;
   bk_close(pevent, pdata);
 
   return bk_size(pevent);
}