#include <vxWorks.h>
#include <taskLib.h>
#include <wdLib.h>
#include <sysLib.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <math.h> /* only for kluge analysis - remove this include later... */

#include "gpib_lib.h"
#include "slow_ctl_cmd.h"
#include "smd_control.h"

/*static UINT16 outbuf[2+2*16*134];*/
static UINT16 *outbuf;
static UINT16 *page_data;
static WDOG_ID report_wdog;
static BOOL ReportFlag;

typedef struct {
  double cpTemp,rdoTemp;
  double feeTemp[48];
  double input_p4_v,input_p4_i,reg_p3r3_v,reg_p3r3_basedrive;
  double input_p6_v,input_p6_i,reg_p5_v;
  double input_m6_v,input_m6_i;
} boxMonitor_type;
boxMonitor_type boxMonitor; /* later, it will be an array of N boxes in system */

typedef struct {
  UINT16 boxDelay,resetDelay,resetWidth;  /* delay control values (12 bits) */
  UINT16 readoutLatency;                  /* readout latency register (7 bits) */
  UINT16 pulserTrigLatency;               /* pulser firing to trigger command generation latency register (7 bits) */
  UINT16 pulserEnable[192];               /* pulser enable (1) or disable (0) per channel */
  UINT16 pulserAmplitude[48];             /* pulser amplitude (12 bits) per FEE board (4 channels) */
  UINT16 modePrePost;                     /* pre/post readout enable (1) or disable (0) - note HW is not implemented */
  UINT16 feeTempEnable[48];               /* FEE board temperature output enable (1) or disable (0) */
  UINT16 feeNormalDataEnable[48];         /* FEE board normal event data enable (1) or disable (0) - ALWAYS USE 1 */
} boxControl_type;
boxControl_type boxControl; /* later, it will be an array of N boxes in system */

STATUS smdCheckStatus(int net_num, UINT8 net_node,
		      UINT16 *pwr_trip_n, UINT16 *done, UINT16 *init_n_done_n) {
  UINT16 response;
  STATUS stat;

  if ((stat=bitOp(net_num,net_node,READ_IO_BIT,PWR_TRIP_N_MASK,&response))!=OK)
    return stat;
  if ((response==1)||(response==0))
    *pwr_trip_n=response;
  else {
    fprintf(stderr,"failed to read I/O bit: response=%04x",response);
    return ERROR;
  }
  if ((stat=bitOp(net_num,net_node,READ_IO_BIT,FPGA_DONE_MASK,&response))!=OK)
    return stat;
  if ((response==0)||(response==1))
    *done=response;
  else {
    fprintf(stderr,"failed to read I/O bit: response=%04x",response);
    return ERROR;
  }
  if ((stat=bitOp(net_num,net_node,READ_IO_BIT,FPGA_INIT_N_DONE_N_MASK,&response))!=OK)
    return stat;
  if ((response==0)||(response==1))
    *init_n_done_n=response;
  else {
    fprintf(stderr,"failed to read I/O bit: response=%04x",response);
    return ERROR;
  }
  return OK;
}

int check_response(UINT16 response) {

  if (response!=SUCCESS) {
    decode_response(response);
    printf("\n");
    return -1;
  }
  else
    return 0;
}

STATUS pageProgram(int net_num, UINT8 net_node, UINT16 page_addr) {
  UINT16 response;
  STATUS stat;
  int i=0,j,k,nsend;
  UINT16 *next;

  /* This function assumes that the CM control register has been properly set up, and that */
  /* the page data to write is already in words 2-133 of page_data */

  /* put opcode and address fields in first two words */
  page_data[0]=(CM_OPCODE_PAGE_PROG_BUF_ONE<<8)|(page_addr>>7);
  page_data[1]=(page_addr<<9);
  
  /* convert the data into serial form and bracket it with CMCS_N asserted */
  outbuf[i++]=CMCLK_MASK;               /* leave CLK high, assert CS */
  for(j=0;j<134;j++)
    for(k=15;k>=0;k--) {
      if (((page_data[j]>>k)&0x0001)==0) {
	outbuf[i++]=CMDIN_N_MASK;       /* CLK low, DIN low */
      }
      else {
	outbuf[i++]=0;                  /* CLK low, DIN high */
      }
      outbuf[i++]=outbuf[i-1]|CMCLK_MASK;  /* CLK high, DIN as before */
    }
  outbuf[i++]=CMCLK_MASK|CMCS_N_MASK;   /* leave CLK high, deassert CS */
 
  /* send it (multiple HDLC transactions are required, because of the length) */
  next=outbuf;
  stat=OK;
  while(i>0) {
    if (i<=MAX_WORDS_WRITE)
      nsend=i;
    else
      nsend=MAX_WORDS_WRITE;
    if ((stat=writeOp(net_num,net_node,FALSE,CM_REG_ADDR,nsend,0,next,&response))!=OK)
      break;
    check_response(response);
    next+=nsend;
    i-=nsend;
  }

  return stat;
}

STATUS smdConfigDownload(int net_num, UINT8 net_node, char *infileName, UINT16 page_addr) {
  UINT16 response;
  STATUS stat=OK;
  UINT16 pwr_trip_n,done,init_n_done_n;
  int i;
  FILE *infile;
  UINT8 inbuf[BUF_MAX];
  const UINT8 header[14]={0x00,0x09,0x0f,0xf0,0x0f,0xf0,0x0f,0xf0,0x0f,0xf0,0x00,0x00,0x01,0x61};
  UINT16 k;
  UINT32 length,npage,ntot=0;

  /***********************/
  /* general preparation */
  /***********************/
  printf("--- STAR EEMC MAPMT Box Configuration Download ---\n");
  page_data = (UINT16 *) malloc(2*134);
  if (page_data==NULL) {
    printf("malloc failed\n");
    return ERROR;
  }
  outbuf = (UINT16 *) malloc(2*(2+2*16*134));
  if (outbuf==NULL) {
    printf("malloc failed\n");
    stat=ERROR;
    goto malloc_outbuf_failed;
  }
  page_addr=page_addr&0x03ff;
  printf("Configuration data file: %s\n",infileName);
  if ((infile=fopen(infileName,"rb"))==NULL) {
    printf("could not open %s for input\n",infileName);
    stat=ERROR;
    goto fopen_failed;
  }
  /* read and compare file header */
  fread(inbuf,sizeof(UINT8),14,infile);
  if (memcmp(inbuf,header,14)!=0) {
    printf("file header format error\n");
    stat=ERROR;
    goto fopen_failed;
  }
  /* read and report other embedded info */
  fread(&k,sizeof(UINT8),2,infile);
  if (k>BUF_MAX-1)
    k=BUF_MAX-1;
  fread(inbuf,sizeof(UINT8),k+1,infile);
  printf("( bitgen from: %s\n",inbuf);
  fread(&k,sizeof(UINT8),2,infile);
  if (k>BUF_MAX-1)
    k=BUF_MAX-1;
  fread(inbuf,sizeof(UINT8),k+1,infile);
  printf("  device: %s\n",inbuf);
  fread(&k,sizeof(UINT8),2,infile);
  if (k>BUF_MAX-1)
    k=BUF_MAX-1;
  fread(inbuf,sizeof(UINT8),k+1,infile);
  printf("  timestamp: %s ",inbuf);
  fread(&k,sizeof(UINT8),2,infile);
  if (k>BUF_MAX-1)
    k=BUF_MAX-1;
  fread(inbuf,sizeof(UINT8),k+1,infile);
  printf("%s\n",inbuf);
  fread(&length,sizeof(UINT8),4,infile);
  printf("  length: 0x%08x bytes )\n",length);
  /* report other info, wait for confirmation to proceed */
  printf("Target HDLC network 0x%x, node 0x%02x, CM pages 0x%03x - 0x%03x\n",
	 net_num,net_node,page_addr,page_addr+((length+263)/264)-1);
  printf("Caution -- you are about to download to MAPMT box configuration memory,\n");
  printf("  are you sure you wish to proceed?\n");
  printf("Hit <return> to proceed, or kill with ^C"); /* should have better escape mechanism */
  getchar();

  /***************************/
  /* set-up to access the CM */
  /***************************/
  /* first, check and report on PWR_TRIP,INIT & DONE state */
  /* if converted to broadcast operation in future, do NOT do this, of course! */
  printf("checking mapmt box status... ");
  if ((stat=smdCheckStatus(net_num,net_node,&pwr_trip_n,&done,&init_n_done_n))!=OK)
    goto chk_failed;
  if (pwr_trip_n==1)
    printf("PWR ok / ");
  else
    printf("PWR tripped / ");
  printf("DONE=%1x / INIT_N/DONE_N=%1x\n",done,init_n_done_n);
  if (pwr_trip_n==0)
    goto pwr_failed;
  printf("asserting PROGRAM line to force disconnect of FPGA from CM...\n");
  if ((stat=bitOp(net_num,net_node,CLR_IO_BIT,FPGA_PROG_N_MASK,&response))!=OK)
    return stat;
  check_response(response);
  printf("checking mapmt box status... ");
  if ((stat=smdCheckStatus(net_num,net_node,&pwr_trip_n,&done,&init_n_done_n))!=OK)
    return stat;
  if (pwr_trip_n==1)
    printf("PWR ok / ");
  else
    printf("PWR tripped / ");
  printf("DONE=%1x / INIT_N/DONE_N=%1x\n",done,init_n_done_n);
  printf("enabling CM control register for writing...\n");
  if ((stat=bitOp(net_num,net_node,CLR_IO_BIT,CM_REG_WE_N_MASK,&response))!=OK)
    return stat;
  check_response(response);
  printf("enabling internal DTACK for CS3 space...\n");
  outbuf[0]=CSR3_OPTION_INTERNAL_DTACK;
  if ((stat=writeOp(net_num,net_node,FALSE,CSR3_OPTION_ADDR,1,0,((void *) outbuf),&response))!=OK)
    return stat;
  check_response(response);
  printf("initializing CM control register...\n");
  outbuf[0]=CMREG_DEFAULTS;
  if ((stat=writeOp(net_num,net_node,FALSE,CM_REG_ADDR,1,0,((void *) outbuf),&response))!=OK)
    return stat;
  check_response(response);
  printf("enabling CM control register output...\n");
  if ((stat=bitOp(net_num,net_node,CLR_IO_BIT,CM_REG_OE_N_MASK,&response))!=OK)
    return stat;
  check_response(response);

  /***********************/
  /* download code to CM */
  /***********************/
  printf("downloading...\n");
  while ((!feof(infile))&&(ntot<length)) {
    npage=fread(page_data+2,sizeof(UINT8),264,infile);
    if (npage<264)                       /* if there's any extra bytes at end of last page... */
      memset(((UINT8 *) page_data)+4+npage,0xff,264-npage);  /* fill them with 0xff */
    printf("\rpage 0x%03x <-- 0x",page_addr);
    for(i=2;i<NPRINT+2;i++)
      printf("%04x",page_data[i]);
    printf("..");
    for(i=134-NPRINT;i<134;i++)
      printf("%04x",page_data[i]);
    if ((stat=pageProgram(net_num,net_node,page_addr))!=OK)
      return stat; /* if we fail, really should un-do some things before returning (this applies elsewhere too!) */
    ntot+=npage;
    page_addr=(page_addr+1)&0x3ff;
  }
  printf("\n");
  if (ntot!=length)
    printf("Warning --- actual length disagrees with length count!");

  /******************************************************************************/
  /* return to setup for normal usage, and initiate programming of FPGA from CM */
  /******************************************************************************/
  printf("disabling CM control register output...\n");
  if ((stat=bitOp(net_num,net_node,SET_IO_BIT,CM_REG_OE_N_MASK,&response))!=OK)
    return stat;
  check_response(response);
  printf("disabling internal DTACK for CS3 space...\n");
  outbuf[0]=CSR3_OPTION_NORMAL;
  if ((stat=writeOp(net_num,net_node,FALSE,CSR3_OPTION_ADDR,1,0,((void *) outbuf),&response))!=OK)
    return stat;
  check_response(response);
  printf("disabling CM control register for writing...\n");
  if ((stat=bitOp(net_num,net_node,SET_IO_BIT,CM_REG_WE_N_MASK,&response))!=OK)
    return stat;
  check_response(response);

  /* need to release PROGRAM now (FPGA will configure, hopefully) */
  printf("de-asserting PROGRAM line (FPGA should configure)...\n");
  if ((stat=bitOp(net_num,net_node,SET_IO_BIT,FPGA_PROG_N_MASK,&response))!=OK)
    return stat;
  check_response(response);
  /* wait, and check INIT & DONE state, report it */
  taskDelay(40);
  printf("checking mapmt box status... ");
  if ((stat=smdCheckStatus(net_num,net_node,&pwr_trip_n,&done,&init_n_done_n))!=OK)
    return stat;
  if (pwr_trip_n==1)
    printf("PWR ok / ");
  else
    printf("PWR tripped / ");
  printf("DONE=%1x / INIT_N/DONE_N=%1x\n",done,init_n_done_n);

  /************/
  /* clean up */
  /************/
 pwr_failed:
 chk_failed:
  fclose(infile);
 fopen_failed:
  free(outbuf);
 malloc_outbuf_failed:
  free(page_data);
  return stat;
}

STATUS smdReConfig(int net_num, UINT8 net_node) {
  UINT16 response;
  STATUS stat;
  UINT16 pwr_trip_n,done,init_n_done_n;

  printf("--- STAR EEMC MAPMT Box Re-Configure ---\n");
  /* first, check and report on PWR_TRIP,INIT & DONE state */
  /* if converted to broadcast operation in future, do NOT do this, of course! */
  printf("checking mapmt box status... ");
  if ((stat=smdCheckStatus(net_num,net_node,&pwr_trip_n,&done,&init_n_done_n))!=OK)
    return stat;
  if (pwr_trip_n==1)
    printf("PWR ok / ");
  else
    printf("PWR tripped / ");
  printf("DONE=%1x / INIT_N/DONE_N=%1x\n",done,init_n_done_n);
  if (pwr_trip_n==0)
    return ERROR;
  printf("asserting PROGRAM line to disconnect FPGA from CM...\n");
  if ((stat=bitOp(net_num,net_node,CLR_IO_BIT,FPGA_PROG_N_MASK,&response))!=OK)
    return stat;
  check_response(response);
  printf("checking mapmt box status... ");
  if ((stat=smdCheckStatus(net_num,net_node,&pwr_trip_n,&done,&init_n_done_n))!=OK)
    return stat;
  if (pwr_trip_n==1)
    printf("PWR ok / ");
  else
    printf("PWR tripped / ");
  printf("DONE=%1x / INIT_N/DONE_N=%1x\n",done,init_n_done_n);
  taskDelay(40);

  /* release PROGRAM now (FPGA will configure, hopefully) */
  printf("de-asserting PROGRAM line (FPGA should configure)...\n");
  if ((stat=bitOp(net_num,net_node,SET_IO_BIT,FPGA_PROG_N_MASK,&response))!=OK)
    return stat;
  check_response(response);
  /* wait, and check INIT & DONE state, report it */
  taskDelay(40);
  printf("checking mapmt box status... ");
  if ((stat=smdCheckStatus(net_num,net_node,&pwr_trip_n,&done,&init_n_done_n))!=OK)
    return stat;
  if (pwr_trip_n==1)
    printf("PWR ok / ");
  else
    printf("PWR tripped / ");
  printf("DONE=%1x / INIT_N/DONE_N=%1x\n",done,init_n_done_n);

  return OK;
}

STATUS smdSetBoxDelay(int net_num, UINT8 net_node, int dacValue) {
  STATUS stat;
  UINT16 response,data;
  UINT32 addr=BOX_DELAY_ADDR;

  data = ((UINT16) dacValue) & 0x03ff;
  printf("setting box delay parameter to %d\n",data);
  if ((stat=writeOp(net_num,net_node,FALSE,addr,1,0,&data,&response))!=OK) {
    printf("addr=%08x data=%04x\n",addr,data);
    return stat;
  }
  if (check_response(response)) {
    printf("addr=%08x data=%04x\n",addr,data);
    return ERROR;
  }
  return OK;
}

STATUS smdSetResetDelay(int net_num, UINT8 net_node, int dacValue) {
  STATUS stat;
  UINT16 response,data;
  UINT32 addr=RESET_DELAY_ADDR;

  data = ((UINT16) dacValue) & 0x03ff;
  printf("setting reset delay parameter to %d\n",data);
  if ((stat=writeOp(net_num,net_node,FALSE,addr,1,0,&data,&response))!=OK) {
    printf("addr=%08x data=%04x\n",addr,data);
    return stat;
  }
  if (check_response(response)) {
    printf("addr=%08x data=%04x\n",addr,data);
    return ERROR;
  }
  return OK;
}

STATUS smdSetResetWidth(int net_num, UINT8 net_node, int dacValue) {
  STATUS stat;
  UINT16 response,data;
  UINT32 addr=RESET_WIDTH_ADDR;

  data = ((UINT16) dacValue) & 0x03ff;
  printf("setting reset width parameter to %d\n",data);
  if ((stat=writeOp(net_num,net_node,FALSE,addr,1,0,&data,&response))!=OK) {
    printf("addr=%08x data=%04x\n",addr,data);
    return stat;
  }
  if (check_response(response)) {
    printf("addr=%08x data=%04x\n",addr,data);
    return ERROR;
  }
  return OK;
}

STATUS smdEnablePulser(int net_num, UINT8 net_node, int chan, int amplitude) {

  if ((chan<0) || (chan>191)) {
    printf("invalid channel number\n");
    return ERROR;
  }
  if ((amplitude<0) || (amplitude>0xfff)) {
    printf("invalid amplitude\n");
    return ERROR;
  }

  boxControl.pulserEnable[chan] = 1;
  boxControl.pulserAmplitude[chan/4] = ((UINT16) amplitude) & 0x0fff;
  return smdSetAllControls(net_num,net_node);
}

STATUS smdDisablePulser(int net_num, UINT8 net_node, int chan) {

  if ((chan<0) || (chan>191)) {
    printf("invalid channel number\n");
    return ERROR;
  }

  boxControl.pulserEnable[chan] = 0;
  return smdSetAllControls(net_num,net_node);
}

STATUS smdEnableAllPulser(int net_num, UINT8 net_node, int amplitude) {
  int i;

  if ((amplitude<0) || (amplitude>0xfff)) {
    printf("invalid amplitude\n");
    return ERROR;
  }

  for(i=0;i<192;i++)
    boxControl.pulserEnable[i] = 1;
  for(i=0;i<48;i++)
    boxControl.pulserAmplitude[i] = ((UINT16) amplitude) & 0x0fff;
  return smdSetAllControls(net_num,net_node);
}

STATUS smdDisableAllPulser(int net_num, UINT8 net_node) {
  int i;

  for(i=0;i<192;i++)
    boxControl.pulserEnable[i] = 0;
  return smdSetAllControls(net_num,net_node);
}

STATUS smdRead(int net_num, UINT8 net_node, UINT32 addr, UINT16 *data) {
  STATUS stat;
  UINT16 response;

  if ((stat=readOp(net_num,net_node,FALSE,addr,1,0,&response,data))!=OK) {
    printf("addr=%08x\n",addr);
    return stat;
  }
  if (check_response(response)) {
    printf("addr=%08x data=%04x\n",addr,*data);
    return ERROR;
  }
  return OK;
}

STATUS smdMonitor(int net_num, UINT8 net_node) {
  static int i=0;
  UINT16 data;
  double open;
  int k,log_it=TRUE;

  /* open input (for offset compensation) */
  if (!smdRead(net_num,net_node,0x02301c,&data))
    open=((double) ((signed short) data));
  /* box and readout board temperatures */
  if (!smdRead(net_num,net_node,MON_CP_TEMP_ADDR,&data))
    boxMonitor.cpTemp=(((double) ((signed short) data))-open)*(-0.107815631);
  if (!smdRead(net_num,net_node,MON_RDO_TEMP_ADDR,&data))
    boxMonitor.rdoTemp=(((double) ((signed short) data))-open)*(-.2004008)-273.15;
  /* FEE board temperatures - read two of forty-eight (round-robin) on every call here */
  if (!smdRead(net_num,net_node,MON_FEE_A_TEMP_ADDR,&data))
    boxMonitor.feeTemp[i]=(((double) ((signed short) data))-open)*(-.2004008)-273.15;
  if (!smdRead(net_num,net_node,MON_FEE_B_TEMP_ADDR,&data))
    boxMonitor.feeTemp[i+24]=(((double) ((signed short) data))-open)*(-.2004008)-273.15;
  /* set up next pair of FEE boards for next time we do this */
  boxControl.feeTempEnable[i]=0;
  smdSetOneFeeCsr(net_num,net_node,i);
  boxControl.feeTempEnable[i+24]=0;
  smdSetOneFeeCsr(net_num,net_node,i+24);
  i = (i+1)%24;
  boxControl.feeTempEnable[i]=1;
  smdSetOneFeeCsr(net_num,net_node,i);
  boxControl.feeTempEnable[i+24]=1;
  smdSetOneFeeCsr(net_num,net_node,i+24);
  /* supply voltages and currents */
  if (!smdRead(net_num,net_node,0x0231c0,&data))
    boxMonitor.input_p4_v=(((double) ((signed short) data))-open)*(-.004008016);
  if (!smdRead(net_num,net_node,0x0231e0,&data))
    boxMonitor.input_p4_i=(((double) ((signed short) data))-open)*(-.002867226); /* tweaked value */
  if (!smdRead(net_num,net_node,0x023010,&data))
    boxMonitor.reg_p3r3_v=(((double) ((signed short) data))-open)*(-.004008016);
  if (!smdRead(net_num,net_node,0x023012,&data))
    boxMonitor.reg_p3r3_basedrive=(((double) ((signed short) data))-open)*(-.004008016);
  if (!smdRead(net_num,net_node,0x023160,&data))
    boxMonitor.input_p6_v=(((double) ((signed short) data))-open)*(-.004008016);
  if (!smdRead(net_num,net_node,0x023120,&data))
    boxMonitor.input_p6_i=(((double) ((signed short) data))-open)*(-.001723748); /* tweaked value */
  if (!smdRead(net_num,net_node,0x023180,&data))
    boxMonitor.reg_p5_v=(((double) ((signed short) data))-open)*(-.004008016);
  if (!smdRead(net_num,net_node,0x0231a0,&data))
    boxMonitor.input_m6_v=(((double) ((signed short) data))-open)*(-.004008016);
  if (!smdRead(net_num,net_node,0x023140,&data))
    boxMonitor.input_m6_i=(((double) ((signed short) data))-open)*(-.001151910); /* tweaked value */
   
  printf("center plate temperature = % 7.3f deg C\n",boxMonitor.cpTemp);
  printf("RDO board temperature = % 7.3f deg C\n",boxMonitor.rdoTemp);
  printf("FEE board temperatures (deg C)\n");
  for(k=0;k<48;k++) {
    if (boxMonitor.feeTemp[k]>-200.0)
      printf(" % 7.3f",boxMonitor.feeTemp[k]);
    else
      printf("     N/A");
    if ( (((k+1)%48)==i) || (((k+1)%48)==i+24) )
      printf("'");
    else
      printf(" ");
    if((k%8)==7)
      printf("\n");
  }
  printf("+4 input voltage = %.3f V\n",boxMonitor.input_p4_v);
  printf("+4 input current = %.3f A\n",boxMonitor.input_p4_i);
  printf("+3.3 regulated voltage = %.3f V\n",boxMonitor.reg_p3r3_v);
  printf("+3.3 regulator base drive voltage = %.3f V\n",boxMonitor.reg_p3r3_basedrive);
  printf("+6 input voltage = %.3f V\n",boxMonitor.input_p6_v);
  printf("+6 input current = %.3f A\n",boxMonitor.input_p6_i);
  printf("+5.0 regulated voltage = %.3f V\n",boxMonitor.reg_p5_v);
  printf("-6 input voltage = %.3f V\n",boxMonitor.input_m6_v);
  printf("-6 input current = %.3f A\n",boxMonitor.input_m6_i);
  printf("total input power = %.2f W\n",
	 boxMonitor.input_p4_v*boxMonitor.input_p4_i
	 +boxMonitor.input_p6_v*boxMonitor.input_p6_i
	 +boxMonitor.input_m6_v*boxMonitor.input_m6_i);
  if (log_it)
    write_boxMonitorLog();
  return OK;
}

void write_boxMonitorLog(void) {
  FILE *logFile;
  int i;

  logFile=fopen("log.dat","a");
  fprintf(logFile,"%ld ",((long) time(NULL)));
  fprintf(logFile,"%.3f %.3f ",boxMonitor.cpTemp,boxMonitor.rdoTemp);
  for(i=0;i<48;i++)
    fprintf(logFile,"%.3f ",boxMonitor.feeTemp[i]);
  fprintf(logFile,"%.3f %.3f %.3f %.3f ",boxMonitor.input_p4_v,boxMonitor.input_p4_i,
	  boxMonitor.reg_p3r3_v,boxMonitor.reg_p3r3_basedrive);
  fprintf(logFile,"%.3f %.3f %.3f %.3f %.3f\n",boxMonitor.input_p6_v,boxMonitor.input_p6_i,
	  boxMonitor.reg_p5_v,boxMonitor.input_m6_v,boxMonitor.input_m6_i);
  fclose(logFile);
}

STATUS smdLoopMonitor(int net_num, UINT8 net_node) {

  while (!smdMonitor(net_num,net_node)) {
    taskDelay(120);
    /* VT100 up-scroll */
    printf("\x1bM\x1bM\x1bM\x1bM\x1bM\x1bM\x1bM\x1bM\x1bM\x1bM\x1bM\x1bM\x1bM\x1bM\x1bM\x1bM\x1bM\x1bM\x1bM");
  }
  return OK;
}   

/* this function writes all control parameters from the boxControl structure to the box */
/* future functions could be written to write only the parameters needing to be updated, to save time */
/* or alternatively/also block up larger transfers... */
STATUS smdSetAllControls(int net_num, UINT8 net_node) {
  STATUS stat;
  UINT16 response,data[5],rdata;
  int i,j;

  data[0] = boxControl.boxDelay & 0x0fff;
  if (((stat=writeOp(net_num,net_node,FALSE,BOX_DELAY_ADDR,1,0,data,&response))!=OK) || (check_response(response)))
    return ERROR;
  data[0] = boxControl.resetDelay & 0x0fff;
  if (((stat=writeOp(net_num,net_node,FALSE,RESET_DELAY_ADDR,1,0,data,&response))!=OK) || (check_response(response)))
    return ERROR;
  data[0] = boxControl.resetWidth & 0x0fff;
  if (((stat=writeOp(net_num,net_node,FALSE,RESET_WIDTH_ADDR,1,0,data,&response))!=OK) || (check_response(response)))
    return ERROR;
  data[0] = boxControl.pulserTrigLatency & 0x007f;
  if (((stat=writeOp(net_num,net_node,FALSE,PULSER_TRIG_LATENCY_ADDR,1,0,data,&response))!=OK) || (check_response(response)))
    return ERROR;
  for(i=0;i<48;i++) {
    /* first of the FEE board registers is the readout latency */
    data[0] = boxControl.readoutLatency & 0x007f;
    /* then PCR0 (the MSB) */
    data[1] = ( boxControl.pulserAmplitude[i] >> 8 ) & 0x000f;
    for(j=0;j<4;j++)
      data[1] |= ( boxControl.pulserEnable[4*i+j]!=0 ? (1<<(j+4)) : 0 );
    /* then PCR1 (the LSB) */
    data[2] = boxControl.pulserAmplitude[i] & 0x00ff;
    /* then the CSR */
    data[3] = ( boxControl.feeTempEnable[i]!=0 ? FEE_CSR_TEMP_ENABLE_MASK : 0 )
      | ( boxControl.feeNormalDataEnable[i]!=0 ? FEE_CSR_DATA_ENABLE_MASK : 0 )
      | ( boxControl.modePrePost!=0 ? FEE_CSR_PREPOST_MASK : 0 );
    /* then the FEE board id register */
    data[4] = i;
    /* send 'em all */
    if (((stat=writeOp(net_num,net_node,FALSE,FEE_BASE_ADDR+i*FEE_BLOCK_SIZE_BYTES+FEE_LATENCY_OFFSET,
		       5,1,data,&response))!=OK)
	|| (check_response(response)))
      return ERROR;
    /* read back the FEE board id register to verify */
    if (((stat=readOp(net_num,net_node,FALSE,FEE_BASE_ADDR+i*FEE_BLOCK_SIZE_BYTES+FEE_BOARD_ID_OFFSET,
		      1,0,&response,&rdata))!=OK)
	|| (check_response(response)))
      return ERROR;
    if (rdata!=i)
      printf("ERROR - readback 0x%02x for FEE board ID @ board 0x%02x (addr 0x%06x)\n",rdata,i,
	     FEE_BASE_ADDR+i*FEE_BLOCK_SIZE_BYTES+FEE_BOARD_ID_OFFSET);
  }
  return OK;
}

/* this function writes only the CSR of a single FEE board from the boxControl structure to the box */
STATUS smdSetOneFeeCsr(int net_num, UINT8 net_node, int fee_num) {
  STATUS stat;
  UINT16 response,data;

  if ((fee_num<0) || (fee_num>47)) {
    printf("invalid FEE board number\n");
    return ERROR;
  }
  data = ( boxControl.feeTempEnable[fee_num]!=0 ? FEE_CSR_TEMP_ENABLE_MASK : 0 )
    | ( boxControl.feeNormalDataEnable[fee_num]!=0 ? FEE_CSR_DATA_ENABLE_MASK : 0 )
    | ( boxControl.modePrePost!=0 ? FEE_CSR_PREPOST_MASK : 0 );
  if (((stat=writeOp(net_num,net_node,FALSE,FEE_BASE_ADDR+fee_num*FEE_BLOCK_SIZE_BYTES+FEE_CSR_OFFSET,
		     1,0,&data,&response))!=OK)
      || (check_response(response)))
    return ERROR;
  return OK;
}

STATUS smdInit(int net_num, UINT8 net_node) {
  STATUS stat;
  UINT16 response,data;
  char boxId[5]="\0\0\0\0\0";
  UINT32 addr;
  int i;

  addr=0x022000;
  if ((stat=readOp(net_num,net_node,FALSE,addr,2,1,&response,(UINT16 *) boxId))!=OK) {
    printf("addr=%08x\n",addr);
    return stat;
  }
  printf("box ID = %s\n",boxId);
 
  addr=0x022004;
  if ((stat=readOp(net_num,net_node,FALSE,addr,1,0,&response,&data))!=OK) {
    printf("addr=%08x data=%04x\n",addr,data);
    return stat;
  }
  printf("read CSR=0x%04x\n",data);
  data=0xbabe;
  if ((stat=writeOp(net_num,net_node,FALSE,addr,1,0,&data,&response))!=OK) {
    printf("addr=%08x data=%04x\n",addr,data);
    return stat;
  }
  printf("wrote CSR=0x%04x\n",data);
  if ((stat=readOp(net_num,net_node,FALSE,addr,1,0,&response,&data))!=OK) {
    printf("addr=%08x data=%04x\n",addr,data);
    return stat;
  }
  printf("read CSR=0x%04x\n",data);

  boxControl.boxDelay = 0;
  boxControl.resetDelay = 420;
  boxControl.resetWidth = 400;
  boxControl.readoutLatency = 12; /* just a dummy line - this has no effect in hardware yet */
  boxControl.pulserTrigLatency = 10; /* this is right for use with the old internally fixed readoutLatency */
  for(i=0;i<192;i++)
    boxControl.pulserEnable[i] = 0; /* disable pulser on all channels */
  for(i=0;i<48;i++) {
    boxControl.feeTempEnable[i] = 0; /* disable FEE board temperature output */
    boxControl.feeNormalDataEnable[i] = 1; /* enable normal data to be written into readout buffer */
  }
  boxControl.modePrePost = 0; /* normal readout mode (pre/post not even implemented yet in hardware) */

  return smdSetAllControls(net_num,net_node);
}

/**************TEMPORARY/KLUGE TESTING FUNCTIONSBELOW HERE******************************/
/* all these functions will need (often major) changes as the FPGA designs are brought */
/* from their present "kluge" form to something like final form                        */

#define RD_BLOCKSIZE 1
STATUS readData(int net_num, UINT8 net_node, char *label, BOOL write_it, int count) {
  STATUS stat=OK;
  int i,j;
  UINT16 data[RD_BLOCKSIZE], response;
  UINT32 addr=0x020020;
  char outFileName[255],*logFileName="data/data.log";
  FILE *outFile=NULL,*logFile;
  double sum=0.0,sumsq=0.0;

  if (write_it) {
    strcpy(outFileName,"data/");
    strcat(outFileName,label);
    strcat(outFileName,".dat");
    printf("opening %s\n",outFileName);
    if ((outFile=fopen(outFileName,"w"))==NULL) {
      printf("unable to open %s for output\n",outFileName);
    }
  }
  if ((logFile=fopen(logFileName,"a"))==NULL) {
    printf("unable to open %s for output\n",logFileName);
    stat=ERROR;
    goto close1;
  }
  printf("running...\r");
  report_wdog=wdCreate();
  wdStart(report_wdog,sysClkRateGet(),((FUNCPTR) setReportFlag),0);    /* start a timer */
  for(i=0;i<count;) {
    if ((stat=readOp(net_num,net_node,FALSE,addr,RD_BLOCKSIZE,0,&response,data))!=OK) {
      printf("addr=%08x data=%04x\n",addr,data[0]);
      goto exit;
    }
    if (check_response(response)) {
      printf("addr=%08x data=%04x\n",addr,data[0]);
      stat=ERROR;
      goto exit;
    }
    /*    for(j=0;j<10;j++)
	  printf("%d: %04x\n",j,data[j]); */
    for(j=0;j<RD_BLOCKSIZE;j++) {
      if ((data[j] & 0xc0c0) != 0xc000) {
	printf("data format error...");
	printf("j=%d addr=%08x data=%04x\n",j,addr,data[j]);
	stat=ERROR;
	goto exit;
      }
      data[j] = ((data[j] & 0x3f00)>>2) | (data[j] & 0x003f);
      sum += (double) data[j];
      sumsq += ((double) data[j])*((double) data[j]);
      i++;    /* need to increment count here, before using in calculations... */
      if (outFile != NULL)
	fprintf(outFile,"%04d\n",data[j]);
      if (ReportFlag) {    /* this is occasionally set by a timer */
	ReportFlag=FALSE;
	printf("label=%s N=%d mu=%#8g sigma=%#8g\r",label,i,sum/i,sqrt(sumsq/i-(sum/i)*(sum/i)));
	if (outFile != NULL)
	  fflush(outFile);
      }
    }
  }
  wdDelete(report_wdog);
  fprintf(logFile,"%s %d %#8g %#8g\n",label,i,sum/i,sqrt(sumsq/i-(sum/i)*(sum/i)));
  printf("label=%s N=%d mu=%#8g sigma=%#8g\n",label,i,sum/i,sqrt(sumsq/i-(sum/i)*(sum/i)));
 exit:
  fclose(logFile);
 close1:
  if (outFile != NULL)
    fclose(outFile);
  return stat;
}

void setReportFlag() {
  ReportFlag=TRUE;
  wdStart(report_wdog,sysClkRateGet(),((FUNCPTR) setReportFlag),0);  /* restart the timer */
}

STATUS readDataForever(int net_num, UINT8 net_node) {
  STATUS stat=OK;
  UINT16 data, response;
  UINT32 addr=0x020020;

  for(;-1;) {
    if ((stat=readOp(net_num,net_node,FALSE,addr,1,0,&response,&data))!=OK) {
      printf("addr=%08x data=%04x\n",addr,data);
      return ERROR;
    }
    if (check_response(response)) {
      printf("addr=%08x data=%04x\n",addr,data);
      return ERROR;
    }
    /*printf("%04x",data);*/
    if ((data & 0xc0c0) != 0xc000) {
      printf("data format error...");
      printf("addr=%08x data=%04x\n",addr,data);
      return ERROR;
    }
    data = ((data & 0x3f00)>>2) | (data & 0x003f);
    printf("%04d\r",data);
  }
}

/* NOTE: the time arguments here are in nanoseconds */
STATUS loopPulseTimeReadData(int net_num, UINT8 net_node, double t0, double t1, double delta_t, int count) {
  char buf[100];
  double t;

  gpibInit();              /* for now, this is hard-coded to talk to the DG535 */
  for(t=t0;t<=t1;t+=delta_t) {
    printf("sending to DG535: ");
    sprintf(buf,"DT2,1,%8E\n",t*1e-9);
    gpibSendData(buf);
    taskDelay(sysClkRateGet()/10);        /* wait 100 ms for delay change to settle */
    sprintf(buf,"%g",t);
    if (readData(net_num,net_node,buf,FALSE,count) != OK)
      return ERROR;
  }
  return OK;
}

/* NOTE: the "time" arguments here are in DAC units (0-1023) */
STATUS loopResetWidthReadData(int net_num, UINT8 net_node, int t0, int t1, int delta_t, int count) {
  char buf[100];
  int t;

  for(t=t0;t<=t1;t+=delta_t) {
    smdSetResetWidth(net_num,net_node,t);
    taskDelay(sysClkRateGet()/10);      /* wait 100 ms for delay change to settle */
    sprintf(buf,"%d",t);
    if (readData(net_num,net_node,buf,FALSE,count) != OK)
      return ERROR;
  }
  return OK;
}

/* NOTE: the "time" arguments here are in DAC units (0-1023) */
STATUS loopResetDelayReadData(int net_num, UINT8 net_node, int t0, int t1, int delta_t, int count) {
  char buf[100];
  int t;

  for(t=t0;t<=t1;t+=delta_t) {
    smdSetResetDelay(net_num,net_node,t);
    taskDelay(sysClkRateGet()/10);       /* wait 100 ms for delay change to settle */
    sprintf(buf,"%d",t);
    if (readData(net_num,net_node,buf,FALSE,count) != OK)
      return ERROR;
  }
  return OK;
}