Subversion Repositories f9daq

#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <time.h>
#include <string.h>
#include <sys/types.h>
#include <sys/time.h>
#include <ctype.h>
#include <unistd.h>

#ifdef MRP
#include <rp.h>
#else
#include "calib.h"
#endif

#include "fpga_osc.h"

#define TRUE -1
#define FALSE 0

int timer_out; struct sigaction oact;

int ctrl_c=0;

void SigInt (int sig) {
  ctrl_c = 1;
}


void timerast (signumber, code, context) int signumber, code; struct sigcontext context; {
  fprintf(stderr, "Timeout\n");
  timer_out = TRUE;
}

void tmlnk (tout) int tout; {
  struct sigaction act;
  struct itimerval tdelay;

  act.sa_handler = timerast;
  sigemptyset (&act.sa_mask);
  act.sa_flags = 0;

  tdelay.it_value.tv_sec = tout / 100;
  tdelay.it_value.tv_usec = 10000 * (tout % 100);
  tdelay.it_interval.tv_sec = 0;
  tdelay.it_interval.tv_usec = 0;

  if (sigaction (SIGALRM, &act, &oact) < 0)
  {
    perror ("sigaction(tmlnk)");
    exit (EXIT_FAILURE);
  }
  if (setitimer (ITIMER_REAL, &tdelay, NULL) < 0)
  {
    perror ("setitimer(tmlnk)");
    exit (EXIT_FAILURE);
  }
}

void tmulk () {
  struct itimerval tdelay;

  tdelay.it_value.tv_sec = 0;
  tdelay.it_value.tv_usec = 0;
  tdelay.it_interval.tv_sec = 0;
  tdelay.it_interval.tv_usec = 0;

  if (setitimer (ITIMER_REAL, &tdelay, NULL) < 0)
  {
    perror ("setitimer(tmulk)");
    exit (EXIT_FAILURE);
  }
  if (sigaction (SIGALRM, &oact, NULL) < 0)
  {
    perror ("sigaction(tmulk)");
    exit (EXIT_FAILURE);
  }
}

#ifndef MRP
rp_calib_params_t rp_calib_params; /** Pointer to externally defined calibration parameters. */ rp_calib_params_t *gen_calib_params = NULL;
#endif
int daq_init (char * buff) {
#ifdef DEBUG
        fprintf (stderr, "Server: init\n");
#endif
   int * hdr = (int *) buff;
   int delay = hdr[0];
   int decimation = hdr[1];
   float threshold_voltage = hdr[2]/1000.;
   fprintf(stderr, "delay = %d\tdecimation = %d\tthreshold = %f\n", delay, decimation, threshold_voltage);

/*

   rp_default_calib_params(&rp_calib_params);
   gen_calib_params = &rp_calib_params;
   if(rp_read_calib_params(gen_calib_params) < 0) {
       fprintf(stderr, "rp_read_calib_params() failed, using default"
           " parameters\n");
   }

*/

  // use this to acquire calibrated offset: int offset = gen_calib_params->fe_ch1_dc_offs;
#ifdef MRP
        if(rp_Init() != RP_OK){
          fprintf(stderr, "Rp api init failed!\n");
        }
        rp_AcqReset();
        const int rpdecimation[6]={RP_DEC_1 ,RP_DEC_8 ,RP_DEC_64,
                                   RP_DEC_1024 ,RP_DEC_8192  ,RP_DEC_65536   };
        rp_AcqSetDecimation(rpdecimation[decimation%6]);
        const int c[2] = {RP_CH_1, RP_CH_2};
        rp_AcqSetTriggerLevel(c[0],threshold_voltage); //Trig level is set in Volts while in SCPI
        rp_AcqSetTriggerLevel(c[1],threshold_voltage);  
        rp_AcqSetTriggerDelay(delay);
        return 0;
#else
  // initialization
  int start = osc_fpga_init();
  if(start)
  {
      printf("osc_fpga_init didn't work, retval = %d",start);
      return -1;
  }

  // set acquisition parameters
  osc_fpga_set_trigger_delay(delay);
  g_osc_fpga_reg_mem->data_dec = decimation;
  osc_fpga_reset();
  g_osc_fpga_reg_mem->chb_thr = osc_fpga_cnv_v_to_cnt(threshold_voltage); //sets trigger voltage
#endif
  fprintf(stderr, "%s : %d\n", __FILE__, __LINE__);
  return 0;
}

int daq_end () {
#ifdef DEBUG
        fprintf (stderr, "Server: end\n");
#endif
#ifdef MRP
  rp_Release();
#else
  osc_fpga_exit();
#endif
  return 0;
}

int daq_clear () {
#ifdef DEBUG
        fprintf (stderr, "Server: clear\n");
#endif
  return 0;
}


int16_t  chdata[16*1024];
float *  chfdata = (float *) chdata;
int daq_run (const char *par, char ** data, int *maxlen)

{
 
  int *data_buf;
  int neve;

  unsigned short *sbuff   = (unsigned short *) (par);
  unsigned short maxeve   = sbuff[0];
  unsigned short nsamples = sbuff[1];
  unsigned short tout     = sbuff[2];
  unsigned char trigger   = par[6];
  unsigned char chmask    = par[7];
  clock_t t,t0;
  neve = 0;

  t0=clock();  
  int eventsize = 0;
  if (chmask & 0x1) eventsize += (nsamples+2);
  if (chmask & 0x2) eventsize += (nsamples+2);
  eventsize+=4;
  int required_size = eventsize * maxeve+3;
 
#ifdef DEBUG
        time_t mtime;
        time(&mtime);
        fprintf (stderr, "daq_run:\tmaxeve %d\tnsamples=%d\ttimeout=%d\ttrigger=%d\tchmask=%d\t%s",  maxeve ,nsamples,tout,trigger,chmask, ctime(&mtime)); //
#endif
   
   
   if (required_size > *maxlen ) {
     free (*data);
     *data = (char *) malloc(required_size *sizeof(int));
     fprintf(stderr, "New Buffer with size %d allocated. Old size %d\n", required_size, *maxlen);
     *maxlen = required_size;
   }

  int *ibuf  = (int *)  (*data);
 
 
  data_buf = ibuf + 3;
  const int sleeptime = 135*nsamples/16386; //135 us for 16386 samples and to fill the 16k ADC buffer/

  for (int ieve=0; ieve < maxeve; ieve++)
    {

#ifdef MRP

rp_AcqStart();
usleep(sleeptime);
rp_AcqSetTriggerSrc(trigger);
timer_out = FALSE;
tmlnk (tout);
rp_acq_trig_src_t source;
do {
  rp_AcqGetTriggerSrc(&source);
  //printf("TRG %d src %d\n", trigger, source);  
  if (timer_out || ctrl_c) break;
} while (source == trigger);
 
tmulk ();
usleep(sleeptime);


#else

       osc_fpga_arm_trigger();
       usleep(sleeptime);
       osc_fpga_set_trigger(trigger);

       while (g_osc_fpga_reg_mem->trig_source != 0){
           if (timer_out || ctrl_c) break;
       }
       // with this loop the program waits until the acquistion is completed before continue.
       int trig_ptr = g_osc_fpga_reg_mem->wr_ptr_trigger; // get pointer to mem. adress where trigger was met
       int * ch_signal[2];
       osc_fpga_get_sig_ptr(&ch_signal[0], &ch_signal[1]);
#endif
       *(data_buf++) = 0x2;
       *(data_buf++) = chmask;

       for (int id = 0;id<2;id++){
         if ( !(chmask & (1 << id)) ) continue;

         *(data_buf++) = id;
         *(data_buf++) = nsamples;
#ifdef MRP
        const int c[2] = {RP_CH_1, RP_CH_2};
        unsigned int isamples = nsamples;  
        rp_AcqGetLatestDataV(c[id], &isamples, (float *) data_buf );
        data_buf+=nsamples;
#else

         const int BUF = 16*1024;
         const int offset =  0;
         if (trig_ptr > (BUF-nsamples)) // Enter logic to transition from end to beginning of cha_signal buffer.
         {
            for (int i=trig_ptr;i<BUF;i++) *(data_buf++) = ch_signal[id][i]-offset;
            for (int i=0;i<nsamples-(BUF-trig_ptr);i++) *(data_buf++) = ch_signal[id][i]-offset;
         }
         else // Enter simple logic to send sampleSize from trigger point
         {
           for (int i=0;i<nsamples;i++) *(data_buf++) = ch_signal[id][trig_ptr + i]-offset;
         }
#endif
       }
       *(data_buf++) = 0x3;
       *(data_buf++) = neve;
       neve++;
       if (ieve+1 % 500 == 0) fprintf(stderr, "Event %d\n", ieve);
       if (timer_out) break;

    }


 
  int *len   = ibuf;
  int *nev   = ibuf + 1;
  float *dt = (float *)(ibuf + 2);
 
  *len   = (data_buf-len)*sizeof(int);
  *nev   = neve;
  t = clock();
  *dt = t-t0;
  *dt /= CLOCKS_PER_SEC;
 
  return *len;
}

#define MAXLEN 0XFFFF
struct RUNHDR {
  unsigned short neve;
  unsigned short nsamples;
  unsigned short tout;
  unsigned char trigger;
  unsigned char mask;
  int nloops ;
  int data [MAXLEN];
} ;


struct INIHDR {
  int delay ;  
  int decimation;
  int threshold;
};


int daq_help(char *fname, struct INIHDR * i, struct RUNHDR *r, int verbosity){

  printf("-o filename ... output filename %s\n", fname);
  printf("-v verbose ... verbosity %d\n", verbosity);
  printf("-b decimation ... decimation %d\n", i->decimation);
  printf("-i timeout ... interrupt timeout %d\n", r->tout);
  printf("-s nsamples ... number of samples %d\n", r->nsamples);
  printf("-d delay ... delay %d\n", i->delay);
  printf("-t trigger ... trigger type %d\n", r->trigger);
  printf("-l level ... trigger level %f\n", i->threshold*0.001);
  printf("-m mask ... channel mask %d\n", r->mask );
  printf("-n neve ... number of events per call %d\n", r->neve);
  printf("-r nloops ... number of calls %d\n", r->nloops);
  return 0;
}



int daq_main( int argc , char ** argv) {
  // intercept routine
  if (signal (SIGINT, SigInt) == SIG_ERR) {
    perror ("sigignore");
  }


  char filename[0xFF]="";


struct INIHDR inihdr = {
  .decimation = 1,
  .threshold = 100,
  .delay = 1024
};



struct RUNHDR runhdr;


  runhdr.neve =10000;
  runhdr.nsamples = 1024;
  runhdr.tout = 1000;
  runhdr.trigger = 1;
  runhdr.mask = 0x1;
  runhdr.nloops = 1;

  int verbose = 0;
  int argdata = 0;

  if (argc <2) {
    daq_help(filename, &inihdr, &runhdr, verbose);
    exit(-1);
  }

  opterr = 0;
  int c;
  while ((c = getopt (argc, argv, "o:v:b:i:s:d:t:l:m:n:r:h")) != -1)
    switch (c) {
      case 'o':
        sprintf(filename,"%s", optarg );
        break; // output
      case 'v':
        verbose = strtoul (optarg,NULL,0);
        break; // verbosity
      case 'b':
        inihdr.decimation = strtoul (optarg,NULL,0);
        break;
      case 'i':
        runhdr.tout = strtoul (optarg,NULL,0);
        break;
      case 's':
        runhdr.nsamples = strtoul (optarg,NULL,0);
        break;
      case 'd':
        inihdr.delay = strtoul (optarg,NULL,0);
        break;
      case 't':
        runhdr.trigger = strtoul (optarg,NULL,0);
        break;
      case 'm':
        runhdr.mask = strtoul (optarg,NULL,0);
        break;
      case 'n':
        runhdr.neve = atoi (optarg);
        break;
      case 'r':
        runhdr.nloops = atoi (optarg);
        break;
      case 'l':
        inihdr.threshold = (int) (1000*atof (optarg));
        break;
      case 'h':
        daq_help(filename, &inihdr, &runhdr, verbose);
        break;
      case '?':
        if (optopt == 'c')
          fprintf (stderr, "Option -%c requires an argument.\n", optopt);
        else if (isprint (optopt))
          fprintf (stderr, "Unknown option `-%c'.\n", optopt);
        else
          fprintf (stderr,
                   "Unknown option character `\\x%x'.\n",
                   optopt);
        return 1;
      default:
        abort ();
    }
  for (int i=optind; i<argc; i++) argdata = strtoul (argv[i],NULL,0);
  if (verbose) daq_help(filename, &inihdr, &runhdr, verbose);
 
  printf("argdata %d nloops %d\n",argdata,runhdr.nloops);

  daq_init((char *)&inihdr);
  FILE *fp=NULL;
  if (strlen(filename)>0) fp = fopen(filename, "wb");
 
 
  int maxlen = MAXLEN;
  char *data = (char *) malloc(maxlen * sizeof(int));
  time_t t,tstart;
  time(&tstart);

  for (int i=0;i< runhdr.nloops;i++){
    int nb =daq_run((const char*) &runhdr, &data, &maxlen);
    if (ctrl_c) break;
    time(&t);
    fprintf(stderr, "Loop %d dt=%d s\n", i, (int)(t-tstart));
   
    if (fp) {
      fprintf(stderr, "Writing %d to %s", nb, filename);
      fwrite(data, 1, nb, fp);
    }
   
  }
  time(&t);
  fprintf(stderr, "Total events %d in  %d s\n", runhdr.nloops*runhdr.neve, (int)(t-tstart));
  if (fp) fclose(fp);
  if (data!=NULL) free(data);
  return 0;
}