/*************************************************************************
*                HB QUICK TEST                                           *
*   Tests one Hit Buffer board.                                          *
*   It performs VME standalone tests first, then data tests              *
*   using two or three other boards: Hit Senderer and Road Senderer.     *
*   One board is also needed as Receiver.                                *
*   Sender and Receiver Boards can be Mergers or HB or AMS.              *
*   Receiver can be same board as one of the Sender, or separate.        *
*                                                                        *
*   Compile this program with: svtvmecomp hb_quick_test                  *
*    also need first to copy hb_address.h from $SVTVME_DIR/src to        *
*    current directory. This may change as SVTVME pacakge evolves        *
*                                                                        *
**************************************************************************/

/*
*** REVISION HISTORY
* 25 May 00: S.Belforte. Original creation from hbqt.c and hbft.c
*                        Still very limited. Sender and Receiver baords
*                        can only be HitBuffers and crate/slot is
*                        hardwired in the code.
*                        No full data test yet, only 4 words.
*                        No Spy Buffer test
*                        Still uses a lot of old vmesvt calls in
*                        addition to new svtvme stuff.
* 10 aug 00: S.Belforte. Adapt previous version to new svtvme library,
*                        now no calls to vmesvt nor fision. Sender can
*                        be HB/AMS/MRG. Receiver is now only a Merger.
* 07 mar 01: S.Belforte  Capable to use TF as receiver. Adatp to new
*                        svtvme return values.
*
**************************************************************************/

#include "svtvme_public.h"


char testCrate[20];

void bit_printn(int v, int pos);
void reset_hb_PowerOnState(svtvme_h board);
int  check_hb_PowerOnState(svtvme_h board);

void define_configuration(svtvme_h *hb1,
			  svtvme_h *HitSender, int *HitSenderType,
			  svtvme_h *RoadSender, int *RoadSenderType,
			  svtvme_h *Receiver, int *ReceiverSpy,
			  int *ReceiverType, int *ReceiverFifo,
			  int *hbslot, int haveAMS);

int main(int argc, char * argv[])
{

  char verb[10];
  uint4   error_flag, error_enable;
  uint4   tmode, hit_spy, roadlimit, phisector;
  uint4   hold, idprom;
  uint4   data, mdata;
  int   status, i, nerr, moreData;
  int   hb1add;
  int haveAMS;
  int silent;
  int hbHoldIsEnabled;
  svtvme_h hb1;
  svtvme_h HitSender, RoadSender, Receiver;
  int HitSenderType, RoadSenderType;
  int ReceiverSpy, ReceiverFifo, ReceiverType;

  uint4 *Hits;
  uint4 *Roads;
  uint4 *Outs;
  uint4 *Data;
  uint4 dummy;
  int nhits, nroads, nouts, nw, nwMax;
  int more;
  int   readw;

  char HitSenderCrate[40];
  char RoadSenderCrate[40];
  char ReceiverCrate[40];

  int HitSenderSlot;
  int RoadSenderSlot;
  int ReceiverSlot;

  int argsOK = 1;

  if  (argc != 5) argsOK = 0;
  if (argsOK) {
    sscanf(argv[1], "%s", testCrate);
    sscanf(argv[2], "%d", &hb1add);
    if (hb1add!=12 && hb1add!=21 && hb1add!=-1) argsOK=0;
    sscanf(argv[3], "%d", &haveAMS);
    sscanf(argv[4], "%d", &silent);
  }

  if (!argsOK) {
    printf("Usage: %s <cpu> <slot> <haveAMS> <silent>\n",argv[0]);
    printf(" cpu     : crate cpu IP name \n");
    printf(" slot    : 12 or 21. In test stand set to -1, then will \n");
    printf("           read all slots from file hb_quick_test_slots.txt \n");
    printf(" haveAMS : if 0 will use merger to send roads and will\n");
    printf("           read all slots from file hb_quick_test_slots.txt \n");
    printf(" silent  : if 0 will ask visual confirmation of LEDs activity\n");
    exit (1);
  }

  strcpy(verb,"zzz");

  define_configuration(&hb1, &HitSender, &HitSenderType, &RoadSender,
		       &RoadSenderType, &Receiver,
		       &ReceiverSpy, &ReceiverFifo,
		       &ReceiverType, &hb1add, haveAMS);

  
  printf("Will QuickTest HitBuffer in slot %d of crate %s\n", hb1add,testCrate);
  
  svtvme_setGlobalFlag(VERBOSE,1);

  svtvme_init(HitSender);
  svtvme_setTmode(HitSender);
  svtvme_init(RoadSender);
  svtvme_setTmode(RoadSender);

  reset_hb_PowerOnState(hb1);

  assert (check_hb_PowerOnState(hb1)==0);

/*
 * Test Enable
 */
  status = svtvme_setTmode(hb1);
  printf(" Test Mode enabled with status %d\n", status);

  status = svtvme_getState(hb1,HB_TMODE,&tmode);
  printf(" Tes Mode state : "); bit_printn(tmode,1);
  assert ( (tmode&1)==1 );
  if (!silent)
    {printf(" did TM enable work ? Is run LED off ?\n");scanf("%s",verb);}

  /*
   * Test R/W Registers
   */
  printf("testing HB_OUTPUT register ... ");
  assert (svtvme_testRegister (hb1,HB_OUT_REG));
  printf("OK\n");

  printf("testing FREEZE_VME register ... ");
  assert (svtvme_testRegister (hb1,HB_VME_FREEZE));
  printf("OK\n");

  printf("testing ERROR_LINE_ENABLE register ... ");
  assert (svtvme_testRegister (hb1,HB_ERROR_EN));
  printf("OK\n");

  printf("testing CDF_ERROR_ENABLE register ... ");
  assert (svtvme_testRegister (hb1,HB_CDFERR_EN));
  printf("OK\n");


  /*
   * Test RAM
   */

  printf("testing ID PROM ... \n");
  assert (svtvme_testIDPROM(hb1));
  printf("ID PROM OK\n\n");
  /*????????
  printf("testing SS_MAP memory ... "); fflush(0);
  assert (svtvme_testMemory(hb1,HB_SS_MAP,1,STOP_AT_FIRST_ERROR,&nerr)==0);
  printf("OK\n");
  
  printf("testing AM_MAP memory ... "); fflush(0);
  assert (svtvme_testMemory(hb1,HB_AM_MAP,1,STOP_AT_FIRST_ERROR,&nerr)==0);
  printf("OK\n");
  ???????*/


/*
 * Init
 */

  status = svtvme_init(hb1);
  printf("\n Init done with status %d\n\n", status);
  status = svtvme_getState(hb1,HB_TMODE,&tmode);
  printf(" Test Mode state : "); bit_printn(tmode,1);
  assert ( (tmode&1)==0 );
  if (!silent)
    {printf(" did Init work ? Is run LED on (GREEN) ?\n");scanf("%s",verb);}

/*
 * DATA PROCESSING
 */


  status = svtvme_init(HitSender);
  status = svtvme_setTmode(HitSender);
  status = svtvme_init(RoadSender);
  status = svtvme_setTmode(RoadSender);

  status = svtvme_init(hb1);
  status = svtvme_setTmode(hb1);
  printf(" Test Mode enabled with status %d\n", status);
  status = svtvme_getState(hb1,HB_TMODE,&tmode);
  assert ( (tmode&1)==1 );

  status = svtvme_setState(hb1,HB_CDFERR_EN, 0);
  status = svtvme_setState(hb1,HB_ERROR_EN, 0);

  /* prepare some generic words to test data paths */
  nwMax=128*1024;
  assert (Data=malloc(nwMax*4));
  assert (Hits=malloc(nwMax*4));
  assert (Roads=malloc(nwMax*4));
  assert (Outs=malloc(nwMax*4));
  Data[0] = 0x255555;
  Data[1] = 0x2aaaaa;
  Data[2] = 0x255555;
  Data[3] = 0x2aaaaa;

  nw=4;
  for (i=0; i<nw; i++) {
    Hits[i] = Data[i];
    Roads[i] = Data[i];
    Outs[i] = Data[i];
  }

  printf("sending Hits..\n");
  svtvme_sendDataOnce(HitSender, nw, Hits, FASTER);
  printf("Hits sent\n");
 /*
 did_ds_blink ?
 check_fifo_status;
 */
  status = svtvme_getState(hb1, HB_HIT_FIFO_REG, &data);
  printf("HIT FIFO STATUS    = %2x  ",data); bit_printn(data, 3);
  assert( data==7 );
  /*
 read words from fifo, check data and EF_;
 */
  readw = svtvme_readAllFifo(hb1, HB_HIT_FIFO, nwMax, Data, &more);
  assert (readw==nw);
  
  for (i=0;i<(nw-1);i++) {
    assert( (Data[i] == (Hits[i] | 0x80000000)));
  }
  assert ( (Data[i]&0x7fffff) == Hits[i] );
  assert ( (Data[i]&0x80000000) == 0 );

  printf("HIT_FIFO data path OK\n");

/*
 same for roads;
 */

  status = svtvme_init(hb1);
  status = svtvme_setTmode(hb1);
  svtvme_sendDataOnce(RoadSender, nw, Roads, FASTER);
  status = svtvme_getState(hb1, HB_ROAD_FIFO_REG, &data);
  printf("ROAD FIFO STATUS    = %2x  ",data); bit_printn(data, 3);
  assert( data==7 );

  readw = svtvme_readAllFifo(hb1, HB_ROAD_FIFO, nwMax, Data, &more);
  assert (readw==nw);
  
  for (i=0;i<(nw-1);i++) {
    assert ( (Data[i] == (Roads[i] | 0x80000000)));
  }
  assert ( (Data[i]&0x7fffff) == Roads[i] );
  assert ( (Data[i]&0x80000000) == 0 );

  printf("ROAD_FIFO data path OK\n");

  /*
 check hold: led, fifo, cable;
 */

  /*dirty trick because merger does not ignore hold, so has
    to clear data sent to AMS=RoadSender */
  svtvme_init(RoadSender);
  svtvme_setTmode(RoadSender);
  svtvme_init(hb1); /* just in AMS spit something out when in run mode */
  svtvme_setTmode(hb1);
  /* end of dirty trick */
  nw=4000;
  printf("Filling Hit fifo to check Hold... ");
  printf("Make sure Hit Ds LED is on (GREEN)\n");
  if (silent)
    svtvme_sendDataOnce(HitSender, nw, Hits, FASTER);
  else
    svtvme_sendDataOnce(HitSender, nw, Hits, SLOWER);
  if (!silent)
    {printf("Was Hit Ds LED on (GREEN) ?");scanf("%s",verb);}
  status = svtvme_getState(hb1, HB_HIT_FIFO_REG, &data);
  printf("HIT FIFO STATUS    = %2x  ",data); bit_printn(data, 3);
  assert( data==5 );
  assert (SenderHold(HitSender));
  if (!silent)
    {printf("Is Hit Hold LED on (RED) ?");scanf("%s",verb);}
  
  status = svtvme_init(hb1);
  status = svtvme_setTmode(hb1);
  /* need to it twice, previous init causes HB to process same data
     so some error bits may be set, make sure we have all cleared */
  status = svtvme_init(hb1);
  status = svtvme_setTmode(hb1);
  nw=4000;
  printf("Filling Road fifo to check Hold... ");
  printf("Make sure Road Ds LED is on (GREEN)\n");
  if (silent)
    svtvme_sendDataOnce(RoadSender, nw, Roads, FASTER);
  else
    svtvme_sendDataOnce(RoadSender, nw, Roads, SLOWER);
  if (!silent)
    {printf("Was Road Ds LED on (GREEN) ?");scanf("%s",verb);}
  status = svtvme_getState(hb1, HB_ROAD_FIFO_REG, &data);
  printf("ROAD FIFO STATUS    = %2x  ",data); bit_printn(data, 3);
  assert( data==5 );
  assert (SenderHold(RoadSender));
  if (!silent)
    {printf("Is Road Hold LED on (RED) ?");scanf("%s",verb);}

  /*
 check overflow: fifo, error, svt error+led, cdferror+led;
 */

  printf("Checking FIFO's overflow, error bits, SVT/CDF error lines\n");
#if 0 /* can't do this from merger yet */
   nw=200;
  svtvme_sendDataOnce(HitSender, nw, Hits, FASTER);
  status = svtvme_getState(hb1, HB_HIT_FIFO_REG, &data);
  printf("HIT FIFO STATUS    = %2x  ",data); bit_printn(data, 3);
  assert( data==1 );
#endif

  if (haveAMS)
    {
      nw=200;
      svtvme_sendDataOnce(RoadSender, nw, Roads, FASTER);
      status = svtvme_getState(hb1, HB_ROAD_FIFO_REG, &data);
      printf("ROAD FIFO STATUS    = %2x  ",data); bit_printn(data, 3);
      assert( data==1 );

      status = svtvme_setState(hb1, HB_ERROR_EN, 3);
      status = svtvme_getState(hb1, HB_ERROR, &data);
      printf("ERROR REGISTER     = %02x  ",data); bit_printn(data, 8);
  /*  assert( data==3 ); this requires also HITS ! */
      assert( data==2 );
      if (!silent)
	{printf("Is SVT_ERROR LED on (YELLOW) ?");scanf("%s",verb);
	printf("Is BACKPLANE Svt_Error LED on (YELLOW) ?");scanf("%s",verb);}

      status = svtvme_setState(hb1, HB_CDFERR_EN, 1);
      status = svtvme_getState(hb1, HB_CDFERR, &data);
      printf("CDF ERROR_ STATUS   = %2x  ",data); bit_printn(data, 1);
      assert( data==0 );
      if (!silent)
	{printf("Is CDF_ERROR LED on (RED) ?");scanf("%s",verb);
	printf("Is BACKPLANE Cdf_Error LED on (RED) ?");scanf("%s",verb);}
    }

  /*
  send output and check data
  */
  status = svtvme_init(hb1);
  status = svtvme_setTmode(hb1);
  if (ReceiverType==MRG || ReceiverType==TF) {
    status = svtvme_setTmode(Receiver);
    status = svtvme_init(Receiver);
    status = svtvme_resetSpy(Receiver, ReceiverSpy);
  }
  else {
    status = svtvme_init(Receiver);
    status = svtvme_setTmode(Receiver);
  }
  if (ReceiverType==TF) svtvme_setState(Receiver, TF_RM_FRZGEN, 0);

  nw = 4;
  svtvme_sendDataOnce (hb1,nw, Outs, FASTER);
  if (ReceiverType==MRG || ReceiverType==TF) {
    readw = svtvme_spyCounter(Receiver, ReceiverSpy);
    if (ReceiverType==TF) svtvme_setState(Receiver, TF_RM_FRZGEN, 1);
    if (ReceiverType==MRG) svtvme_setTmode(Receiver);
    svtvme_readSpyTail(Receiver, ReceiverSpy, readw, Data);
  }
  else {

      readw= svtvme_readAllFifo(Receiver, ReceiverFifo, nwMax, Data, &more);
    }
  printf("Sent 4 words, found %d in receiver\n",readw);
  assert(readw==4);
  for (i=0;i<readw;i++) {
    assert ( (Data[i]&0x7fffff) == Outs[i] );
  }
  printf("OUTPUT data path OK\n");
  if (ReceiverType=TF) svtvme_setState(Receiver, TF_RM_FRZGEN, 0);

  /*
 stop receiver, overflow it, check ds & hold led & status;
 */
  status = svtvme_getState(hb1,HB_SWITCHES, &data);
  printf("DIP SWITCHES       = %2x  ",data); bit_printn(data, 4);
  hbHoldIsEnabled = (data>>3) & 0x1;
  if (hbHoldIsEnabled)
    printf("HitBuffer output hold is Enabled\n");
  else
    printf("HitBuffer output hold is NOT Enabled\n");
  nw = 4000;
  printf("Filling Receiver fifo to check LED & Hold... ");
  printf("Make sure OUT Ds LED is on (GREEN)\n");
  svtvme_setTmode(Receiver);
  /*  if (ReceiverType=TF) svtvme_setState(Receiver, TF_TMODE, 0); */
  if (ReceiverType=TF) svtvme_setState(Receiver, TF_IFIFO_DSBL, 1);
  if (silent)
    svtvme_sendDataOnce (hb1, nw, Outs, FASTER);
  else
    svtvme_sendDataOnce (hb1, nw, Outs, SLOWER);
  if (!silent)
    {printf("Was Out Ds LED on (GREEN) ?");scanf("%s",verb);}
  if (hbHoldIsEnabled)
    {
      data = svtvme_isHeld(hb1);
      printf("OUTPUT HOLD STATUS    = %1x  ",data); bit_printn(data, 1);
      assert( data==1 );
      if (!silent)
	{printf("Is Out Hold LED on (RED) ?");scanf("%s",verb);}
    }
  /* now do it in run mode and check spy buffer data path */
  /*
    prepare simple ssmap & ammap, allow jhit/road=all-5 and all-a
    plus allow simple invalid hit/road;
    load simple ssmap & am_map ;
    send hit & road :
    check spys;
    send invalid data & check;
    send parity error & check;
    send lost sync & check;
    stop receiver, send dummy until hold, check hb data flow stops;
        send 5k 600000hex on hit
	send 5k 600000hex on roads
	check test HB ospy ptr = 3969
	flush receiver
	check test HB ospy ptr = 5000 (anyhow > 3969)
    */

  /* all done, now must run extensive ram/ss tests and random test */
 

  reset_hb_PowerOnState(hb1);
  svtvme_setTmode(hb1);

  svtvme_closeBoard(hb1);
  svtvme_closeBoard(HitSender);
  if (haveAMS) svtvme_closeBoard(RoadSender);
  svtvme_closeBoard(Receiver);
}

/*==================================================================*/
/*====================  END OF MAIN  ===============================*/
/*==================================================================*/


/*------------------------------------------------------------------*/

void reset_hb_PowerOnState(svtvme_h board)
{
  int status;
  status = svtvme_setState(board,HB_ERROR_EN, 0xFF);
  status = svtvme_setState(board,HB_CDFERR_EN, 0);
  status = svtvme_init(board);
}

/*------------------------------------------------------------------*/

int check_hb_PowerOnState(svtvme_h board){
int status;
uint4 data;

  /*
   * Dump and check HB PowerOn state
   */

  status = svtvme_getState(board,HB_TMODE, &data);
  printf(" Test Mode state : "); bit_printn(data,1);
  assert( data==0 );

  status = svtvme_getState(board,HB_ERROR, &data);
  printf("ERROR REGISTER     = %02x  ",data); bit_printn(data, 8);
  assert( data==0 );

  status = svtvme_getState(board,HB_HIT_FIFO_REG, &data);
  printf("HIT FIFO STATUS    = %2x  ",data); bit_printn(data, 3);
  assert( data==6 );

  status = svtvme_getState(board,HB_ROAD_FIFO_REG, &data);
  printf("ROAD FIFO STATUS   = %2x  ",data); bit_printn(data, 3);
  assert( data==6 );

  status = svtvme_getState(board, HB_OUT_HOLD, &data);
  printf("OUTPUT HOLD STATUS = %2x  ",data); bit_printn(data, 1);

  status = svtvme_getState(board, HB_FSM, &data);
  printf("FSM STATUS         = %2x  ",data); bit_printn(data, 4);
  assert( data==0 );

  status = svtvme_getState(board, HB_HF_FSM, &data);
  printf("FSMH STATUS        = %2x  ",data); bit_printn(data, 2);
  assert( data==3 );

  status = svtvme_getState(board, HB_RF_FSM, &data);
  printf("FSMR STATUS        = %2x  ",data); bit_printn(data, 2);
  assert( data==0 );

  status = svtvme_getState(board,HB_VME_FREEZE, &data);
  printf("FREEZE VME         = %2x  ",data); bit_printn(data, 1);
  assert( data==0 );

  assert ( test_spy_reg(HB_HIT_SPY, board) );
  assert ( test_spy_reg(HB_ROAD_SPY, board) );
  assert ( test_spy_reg(HB_OUT_SPY, board) );

  status = svtvme_getState(board,HB_ERROR_EN, &data);
  printf("SVT ERROR ENABLE   = %02x  ",data); bit_printn(data, 8);
  assert( data==0xFF );

  status = svtvme_getState(board,HB_CDFERR_EN, &data);
  printf("CDF ERROR ENABLE   = %2x  ",data); bit_printn(data, 1);
  assert( data==0 );

  status = svtvme_getState(board,HB_CDFERR, &data);
  printf("CDF ERROR STATUS   = %2x  ",data); bit_printn(data, 1);
  assert( data==1 );

  status = svtvme_getState(board,HB_SWITCHES, &data);
  printf("DIP SWITCHES       = %2x  ",data); bit_printn(data, 4);
  /*  assert( data==13 );*/

  return (status);
}
/*------------------------------------------------------------------*/

int test_spy_reg(uint4 spy, svtvme_h board){
  int status;
  int ptr, frz, wrp;
  char reg[4];
  uint4 data,mdata;

  if (spy == HB_HIT_SPY)
    strcpy(reg,"HIT");
  else if (spy == HB_ROAD_SPY)
    strcpy(reg,"ROAD");
  else if (spy == HB_OUT_SPY)
    strcpy(reg,"OUT");
  else
    {
      printf("test_hb_spy- wrong 1st argument: %d\n",spy);
    return 0;
    }

  data = svtvme_spyCounter(board, spy);
  if (data != 0) {
    printf("%s SPY POINTER = %05x  ",reg, data); bit_printn(data, 17);
    printf ("    Try to reset it: ");
    status = svtvme_resetSpy(board,spy);
    data = svtvme_spyCounter(board, spy);
    printf("%s SPY POINTER = %05x  ",reg, data); bit_printn(data, 17);
  }
  assert( data==0 );

  data = svtvme_isWrapped(board,spy);
  printf("%s SPY WRAP       = %2x  ",reg, data); bit_printn(data, 1);
  assert( data==0 );

  data = svtvme_isFrozen(board, spy);
  printf("%s SPY FREEZE     = %2x  ",reg, data); bit_printn(data, 1);
  assert( data==0 );

  return 1;
}

/*------------------------------------------------------------------*/
#if 1
void bit_printn(int v, int pos)

{
  int i, mask = 1 << 31;
  
  if (pos > 32) i = 32;
  for (i=1;i <= (32-pos); ++i) {
    v <<= 1;
  }
  for (i=1;i <= pos; ++i) {
    putchar(((v & mask) == 0) ? '0' : '1');
    v <<=1;
    if ((32 - pos + i) % 8 ==0 && i != 32) putchar(' ');
  }
  printf("\n");

}
#endif

/*==================================================================*/
/*====================  DATA SEND/READ STUFF =======================*/
/*==================================================================*/

void define_configuration(svtvme_h *hb1,
			  svtvme_h *HitSender, int *HitSenderType,
			  svtvme_h *RoadSender, int *RoadSenderType,
			  svtvme_h *Receiver, int *ReceiverSpy,
			  int *ReceiverFifo,
			  int *ReceiverType, int *hbslot, int haveAMS)
{
  char HitSenderCrate[40];
  char RoadSenderCrate[40];
  char ReceiverCrate[40];

  char HStype[40];
  char RStype[40];
  char Rctype[40];
  char spy[40];

  int HitSenderSlot;
  int RoadSenderSlot;
  int ReceiverSlot;

  FILE *fp;

  HitSenderSlot = 0;
  RoadSenderSlot = 0;
  ReceiverSlot = 0;

  strcpy (HitSenderCrate,testCrate);
  if (*hbslot==12) HitSenderSlot=7;
  if (*hbslot==21) HitSenderSlot=16;
  strcpy (RoadSenderCrate,testCrate);
  if (haveAMS)
    {
      if (*hbslot==12) RoadSenderSlot=8;
      if (*hbslot==21) RoadSenderSlot=17;
    }
  else RoadSenderSlot = HitSenderSlot;
  strcpy (ReceiverCrate,"b0svt06");
  *ReceiverType = TF;
  *ReceiverSpy = TF_ISPY;
  if (!strcmp(testCrate,"b0svt00")) ReceiverSlot=4;
  if (!strcmp(testCrate,"b0svt01")) ReceiverSlot=6;
  if (!strcmp(testCrate,"b0svt02")) ReceiverSlot=8;
  if (!strcmp(testCrate,"b0svt03")) ReceiverSlot=10;
  if (!strcmp(testCrate,"b0svt04")) ReceiverSlot=12;
  if (!strcmp(testCrate,"b0svt05")) ReceiverSlot=14;
  if (*hbslot==12) ;
  if (*hbslot==21) ReceiverSlot += 1;

  if (*hbslot==-1 || !haveAMS)
    {
      assert( fp=fopen("hb_quick_test_slots.txt","r") );
      fscanf(fp,"hb_slot         : %d\n", hbslot);
      fscanf(fp,"HitSender   slot: %d\n", &HitSenderSlot);
      fscanf(fp,"HitSender   type: %s\n", HStype);
      fscanf(fp,"RoadSender  slot: %d\n", &RoadSenderSlot);
      fscanf(fp,"RoadSender  type: %s\n", RStype);
      fscanf(fp,"Receiver    slot: %d\n", &ReceiverSlot);
      fscanf(fp,"HitSender  crate: %s\n", HitSenderCrate);
      fscanf(fp,"RoadSender crate: %s\n", RoadSenderCrate);
      fscanf(fp,"Receiver   crate: %s\n", ReceiverCrate);
      fscanf(fp,"Receiver    type: %s\n", Rctype);
      fscanf(fp,"Receiver     spy: %s\n", spy);
      fclose(fp);
      if (!strcmp(HStype,"MRG")) *HitSenderType = MRG;
      else if (!strcmp(HStype,"HB")) *HitSenderType = HB ;
      else if (!strcmp(HStype,"TF")) *HitSenderType = TF ;
      else if (!strcmp(HStype,"HF")) *HitSenderType = HF ;
      else if (!strcmp(HStype,"AMS")) *HitSenderType = AMS ;
      else {printf("Unknown HitSenderType %s. Abort\n",HStype); exit (1);}

      if (!strcmp(RStype,"MRG")) *RoadSenderType = MRG;
      else if (!strcmp(RStype,"HB")) *RoadSenderType = HB ;
      else if (!strcmp(RStype,"TF")) *RoadSenderType = TF ;
      else if (!strcmp(RStype,"HF")) *RoadSenderType = HF ;
      else if (!strcmp(RStype,"AMS")) *RoadSenderType = AMS ;
      else {printf("Unknown RoadSenderType %s. Abort\n",RStype); exit (1);}

      if (!strcmp(Rctype,"MRG")) *ReceiverType = MRG;
      else if (!strcmp(Rctype,"TF")) *ReceiverType = TF ;
      else if (!strcmp(Rctype,"AMS")) *ReceiverType = AMS ;
      else {printf("Unknown ReceiverType %s. Abort\n",Rctype); exit (1);}
      if (*ReceiverType==TF) *ReceiverSpy = TF_ISPY;
      else if (*ReceiverType==AMS) *ReceiverFifo = AMS_HIT_FIFO;
      else if (*ReceiverType==MRG) {
	if (!strcmp(spy,"A")) *ReceiverSpy = MRG_A_SPY;
	else if (!strcmp(spy,"B")) *ReceiverSpy = MRG_B_SPY;
	else if (!strcmp(spy,"C")) *ReceiverSpy = MRG_C_SPY;
	else if (!strcmp(spy,"D")) *ReceiverSpy = MRG_D_SPY;
	else {printf("Unknown ReceiverSpy %s. Abort\n",spy);exit (1);}
      }
      else {printf("Unknown Receiver %s. Abort\n",Rctype);exit (1);}
    }

  *hb1 = svtvme_openBoard(testCrate, *hbslot, HB);

  *HitSender = svtvme_openBoard(HitSenderCrate, HitSenderSlot,
				*HitSenderType);
  if (haveAMS)
    *RoadSender = svtvme_openBoard(RoadSenderCrate, RoadSenderSlot,AMS);
  else
    *RoadSender = svtvme_openBoard(RoadSenderCrate, RoadSenderSlot,
				   *RoadSenderType);
  *Receiver = svtvme_openBoard(ReceiverCrate, ReceiverSlot, *ReceiverType);

}

/*------------------------------------------------------------------*/

int SenderHold(svtvme_h board)
{
  int status;
  int data;

  
  if (svtvme_boardType(board)==MRG) data=1;
  else data = svtvme_isHeld (board);

  return (data);
}
/*------------------------------------------------------------------*/

/*------------------------------------------------------------------*/