/*
  gcc -Wall -o saltroregtest saltroregtest.c
*/
#include <getopt.h>
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <unistd.h>

#define FEC 0
#define CHIP 0
#define CHANNEL 0

//#define LOCAL_IP "130.235.185.193"
//#define SRU_IP "130.235.185.193"
#define LOCAL_IP "192.168.4.11"
#define SRU_IP "192.168.4.4"

#define SRU_WAIT_WRITE 500

int logdata = 0; // default is to log data
char csvfile[256];

unsigned int fec,valuerd,valuewr,writeval;
int loop;
int chip;
int channel;
int reg;
int verify;
int mychan;
int signal_stop = 0;
int nberr;

unsigned long bfnpt[8],bc1thr[8],bc2thr[8],trcfg[8],dpcfg[8],pmadd[8];
unsigned long k1[128],k2[128],k3[128],k4[128],l1[128],l2[128],l3[128],l4[128];
unsigned long zsthr[128],vfped[128],pmdta[128],cte[128];

int errbfnpt[8] = {0};
int errbc1thr[8] = {0};
int errbc2thr[8] = {0};
int errtrcfg[8] = {0};
int errdpcfg[8] = {0};
int errpmadd[8] = {0};
int errk1[128] = {0};
int errk2[128] = {0};
int errk3[128] = {0};
int errk4[128] = {0};
int errl1[128] = {0};
int errl2[128] = {0};
int errl3[128] = {0};
int errl4[128] = {0};
int errzsthr[128] = {0};
int errvfped[128] = {0};
int errpmdta[128] = {0};
int errcte[128] = {0};



int ret1bc1thr = 0;
int ret2bc1thr = 0;
int bc1thrwr = 0;
int nbrdbc1thr = 0;

int ret1bc2thr = 0;
int ret2bc2thr = 0;
int bc2thrwr = 0;
int nbrdbc2thr = 0;

int ret1bfnpt = 0;
int ret2bfnpt = 0;
int bfnptwr = 0;
int nbrdbfnpt = 0;

int ret1trcfg = 0;
int ret2trcfg = 0;
int trcfgwr = 0;
int nbrdtrcfg = 0;

int ret1dpcfg = 0;
int ret2dpcfg = 0;
int dpcfgwr = 0;
int nbrddpcfg = 0;

int ret1pmadd = 0;
int ret2pmadd = 0;
int pmaddwr = 0;
int nbrdpmadd = 0;

int ret1k1[128] = {0};
int ret2k1[128] = {0};
int k1wr[128] = {0};
int ret1k2[128] = {0};
int ret2k2[128] = {0};
int k2wr[128] = {0};
int ret1k3[128] = {0};
int ret2k3[128] = {0};
int k3wr[128] = {0};
int ret1k4[128] = {0};
int ret2k4[128] = {0};
int k4wr[128] = {0};

int nbrdk1[128] = {0};
int nbrdk2[128] = {0};
int nbrdk3[128] = {0};
int nbrdk4[128] = {0};

int ret1l1[128] = {0};
int ret2l1[128] = {0};
int l1wr[128] = {0};
int ret1l2[128] = {0};
int ret2l2[128] = {0};
int l2wr[128] = {0};
int ret1l3[128] = {0};
int ret2l3[128] = {0};
int l3wr[128] = {0};
int ret1l4[128] = {0};
int ret2l4[128] = {0};
int l4wr[128] = {0};

int nbrdl1[128] = {0};
int nbrdl2[128] = {0};
int nbrdl3[128] = {0};
int nbrdl4[128] = {0};

int ret1zsthr[128] = {0};
int ret2zsthr[128] = {0};
int zsthrwr[128] = {0};
int nbrdzsthr[128] = {0};

int ret1vfped[128] = {0};
int ret2vfped[128] = {0};
int vfpedwr[128] = {0};
int nbrdvfped[128] = {0};

int ret1cte[128] = {0};
int ret2cte[128] = {0};
int ctewr[128] = {0};
int nbrdcte[128] = {0};


typedef struct {
  char controlip[64];
  int controlport;
  struct sockaddr_in si_sru;
  int scsocket; // socket for slow control
  int listenport;
  char readoutip[64];
  unsigned int readoutipnb;
  int status; // status from configfile
  int linkup; // it it answered ping
  int active; // status & linkup is set and FMVER could be read
} SRUSERVER;


typedef struct {
  struct sockaddr_in si_controlme;
  int controlsocket; // socket for control
  int listenport; // port for listen on control
  int nbrdpackets; // Number of packets expected back
  SRUSERVER sruserver;
} SRU;

/* SRU part */
int scSruConnect(SRU *srus)
{
  int s;
  struct timeval timeout;
  timeout.tv_sec = 0;
  timeout.tv_usec = 500000;

  if ((s=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP))==-1) {
    printf("%s: socket error %s\n",__FUNCTION__,strerror(errno));
    return -1;
  }
  setsockopt(s, SOL_SOCKET, SO_RCVTIMEO,&timeout,sizeof(timeout));
  memset((char *) &srus->si_controlme, 0, sizeof(struct sockaddr));
  srus->si_controlme.sin_family = AF_INET;
  srus->si_controlme.sin_port = htons(srus->listenport);
  if (inet_aton(LOCAL_IP, &srus->si_controlme.sin_addr)==0) {
    printf("%s: inet_aton error %s\n",__FUNCTION__,strerror(errno));	
    close(s);
    return -2;
  }
  if (bind(s, (struct sockaddr *)&srus->si_controlme, sizeof(struct sockaddr)) != 0) {
    printf("%s: bind error %s\n",__FUNCTION__,strerror(errno));	
    close(s);
    return -3;
  }
  srus->controlsocket = s;

  memset((char *) &srus->sruserver.si_sru, 0, sizeof(struct sockaddr_in));
  srus->sruserver.si_sru.sin_family = AF_INET;
  srus->sruserver.si_sru.sin_port = htons(srus->sruserver.controlport);
  if (inet_aton(srus->sruserver.controlip, &srus->sruserver.si_sru.sin_addr)==0) {
    printf("%s: sru inet_aton error %s\n",__FUNCTION__,strerror(errno));	
    close(s);
    srus->controlsocket = 0;
    return -4;
  }
  return 0;
}


/* SALTRO part */
int saltroWriteRegister(int handle,SRUSERVER *srv,int broadcast, int node, int chip, int channel, int reg, unsigned int value)
{
  unsigned int buf[4];
  int s_sent,s_bytes;
  socklen_t s_length=sizeof(srv->si_sru);
  unsigned int myreg;


  if (node >= 20) {
    buf[0] = htonl(1 << (node - 20));
    buf[1] = 0;
  }
  else {
    buf[0] = 0;
    buf[1] = htonl(1 << node);
  }
  myreg = (node << 12) | (chip << 9) | (channel << 5) | reg;
  buf[2] = htonl(myreg | 0x40000000);
  buf[3] = htonl(value);
  s_bytes = 16;
  if ( (s_sent = sendto(handle, buf, 16, 0, (struct sockaddr *)&srv->si_sru, s_length)) ==-1) {
    return -1;
  }
  if (s_sent != s_bytes) {
    return -2;
  }
  usleep(SRU_WAIT_WRITE);
  return 0;
}

int saltroReadRegister(int handle, SRUSERVER *srv, int node, int chip, int channel, int reg, unsigned int *value)
{
  unsigned int buf[20];
  int s_sent,s_bytes;
  socklen_t s_length=sizeof(srv->si_sru);
  struct sockaddr_in si_from;
  socklen_t si_fromlen=sizeof(si_from);
  unsigned int myreg,mynode;
  unsigned int myregrd;
  if (node >= 20) {
    buf[0] = htonl(1 << (node - 20));
    buf[1] = 0;
  }
  else {
    buf[0] = 0;
    buf[1] = htonl(1 << node);
 }

  myregrd = (node << 12) | (chip << 9) | (channel << 5) | reg;
  buf[2] = htonl(myregrd | 0xC0000000);
  buf[3] = 0;
  s_bytes = 16;
  if ( (s_sent = sendto(handle, buf, 16, 0, (struct sockaddr *)&srv->si_sru, s_length)) ==-1) {
    return -1;
  }
  if (s_sent != s_bytes) {
    return -2;
  }
  if ((s_bytes = recvfrom(handle, buf,sizeof(buf), 0, (struct sockaddr *) &si_from, &si_fromlen))==-1) {
    printf("CH %d CH %d REG %d ",chip,channel,reg);
    perror("-3");
    return -3;
  }
  if (s_bytes != 12) {
    return -4;
  }

  if (si_from.sin_addr.s_addr != srv->si_sru.sin_addr.s_addr) {
    printf("%s: Received illegal packet (lengh = %d) from %s: %d\n",__FUNCTION__,s_bytes, 
	   inet_ntoa(si_from.sin_addr), ntohs(si_from.sin_port));
    return -5;
  }
 
  mynode = ntohl(buf[0]);
  if (mynode != node) {
    printf("%s: Received not expected node %08X expected %08X\n",
	   __FUNCTION__,mynode,node);
    return -6;
  }
  myreg = ntohl(buf[1]);
  if (myreg != (myregrd | 0xC0000000)) {
    printf("%s: Received not expected register %08X expected %08X\n",
	   __FUNCTION__,myreg,myregrd | 0xC0000000);
    return -7;
  }
  *value = ntohl(buf[2]);

  return 0;
}

void signal_handler(int signum)
{
  switch(signum) {
  case SIGQUIT:
  case SIGTERM:
  case SIGINT:
    puts("\nSIGTERM");
    signal_stop = 1; 
    exit(0);
    break;
    /*
  case SIGTERM:
  case SIGQUIT: break;
    */
  }
}



int decodeParameters(int argc, char **argv)
{
  int c;
  int option_index = 0;
  char *short_options = "C:c:f:hl:o:p:r:vw:";
  const struct option long_options[]=
  {
    {"chip",1,0,'C'},
    {"channel",1,0,'c'},
    {"fec",1,0,'f'},
    {"help",0,0,'h'},
    {"loop",1,0,'l'},
    {"outfile",1,0,'o'},
    {"pattern",1,0,'p'},
    {"register",1,0,'r'},
    {"write",1,0,'w'},
    {"verify",0,0,'v'},
  };
  channel = CHANNEL;
  chip = CHIP;
  fec = FEC;
  loop = 1;
  verify = 0;
  valuewr = 0;
  mychan = 0;
  writeval = 0;
  logdata = 0; // log the data on file
  if (argc > 1)
  {
    while ((c = getopt_long(argc, argv, short_options,
                                        long_options, &option_index)) != EOF)
    {
      switch (c)
      {
      case 'C': sscanf(optarg,"%d",&chip); break;
      case 'c': sscanf(optarg,"%d",&channel); break;
      case 'f': sscanf(optarg,"%d",&fec); break;
      case 'h':
	puts("Options");
	puts("--fec <fec>");
	puts("--chip <chip>");
	puts("--channel <channel>");
	puts("--register <register in hex>");
	puts("--write <value in hex>");
	puts("--loop <number of loops, 0 = infinity>");
	puts("--verify <verify written value>");
	return 1;
	break;
      case 'l': sscanf(optarg,"%d",&loop); break;
      case 'o':
	strcpy(csvfile,optarg);
	printf("FILE %s\n",csvfile);
	logdata = 1;
	break;
      case 'p': sscanf(optarg,"%X",&mychan); break;
      case 'r': sscanf(optarg,"%X",&reg);break;
      case 'v': verify = 1; break;
      case 'w': sscanf(optarg,"%X",&writeval); break;
      }
    }
  }
  return 0;
}

int cmpreg(int fec,int chip,int ch,int reg,unsigned int in1,unsigned int in2,int verify)
{
  int err = 0;
  if (in1 != in2) {
    err = 1;
    if (verify) {
      printf("FEC %2d CHIP %2d CH %2d REG %03X READ %08X WRITE %08X\n",fec,chip,ch,reg,in1,in2);
    }
  } 
  return err;
}

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

  SRU srus;
  int cont,ret,ret1,ret2;
  FILE *fcsv;  
  int errst;

    int j,k,ch;

    signal(SIGINT,signal_handler);
    signal(SIGQUIT,signal_handler);
    signal(SIGTERM,signal_handler);

    strcpy(srus.sruserver.controlip,SRU_IP);
    srus.sruserver.controlport = 4097;
    srus.listenport = 4100;


    if (decodeParameters(argc,argv)) exit(0);
    printf("Parameters: FEC= %d LOOP %d CHANNELS %04X\n",fec,loop,mychan);
    errst = scSruConnect(&srus);
    if (errst != 0) {
      printf("scSruConnect returned %d\n",errst);
      return(0);
    }
    printf("START TEST");
    cont = 1;
    nberr = 0;

    while(cont) {


  //WRITE REGISTERS
      ret1 = ret2 = 0;
      for (j = chip; j <=chip; j++) {
	// Global registers
	// BC2THR
	valuewr = (j << 3) + 2;
	if ((cont % 5) == 1)  valuewr = ~valuewr;
	else if ((cont % 5) == 2) valuewr = (rand() % 0xFFFFF);
	else if ((cont % 5) == 3) valuewr = cont;
	else if ((cont % 5) == 4) valuewr = writeval;
	valuewr &= 0xFFFFF;
	bc2thr[j] = valuewr;
	bc2thrwr = 1;
	if ((ret =saltroWriteRegister(srus.controlsocket,&srus.sruserver,0,fec,j,0,0x09,valuewr)) != 0) {
	  ret1bc2thr++;
	  ret1++;
	  bc2thrwr = 0;
	}
	// TRCFG
	valuewr = (j << 3) + 3;
	if ((cont % 5) == 1)  valuewr = ~valuewr;
	else if ((cont % 5) == 2) valuewr = (rand() % 0xFFFFF);
	else if ((cont % 5) == 3) valuewr = cont;
	else if ((cont % 5) == 4) valuewr = writeval;
	valuewr &= 0xFFFFF;
	trcfg[j] = valuewr;
	trcfgwr = 1;
	if ((ret = saltroWriteRegister(srus.controlsocket,&srus.sruserver,0,fec,j,0,0x0A,valuewr)) != 0) {
	  ret1trcfg++;
	  ret1++;
	  trcfgwr = 0;
	}
	// DPCFG
	valuewr = (j << 3) + 4;
	if ((cont % 5) == 1)  valuewr = ~valuewr;
	else if ((cont % 5) == 2) valuewr = (rand() % 0xFFFFF);
	else if ((cont % 5) == 3) valuewr = cont;
	else if ((cont % 5) == 4) valuewr = writeval;
	valuewr &= 0x7FFFF; // enable zerosuppression not used
	dpcfg[j] = valuewr;
	dpcfgwr = 1;
	if ((ret = saltroWriteRegister(srus.controlsocket,&srus.sruserver,0,fec,j,0,0x0B,valuewr)) != 0) {
	  ret1dpcfg++;
	  ret1++;
	  dpcfgwr = 0;
	}
	// BFNPT
	valuewr = (j << 3) + 0;
	if ((cont % 5) == 1)  valuewr = ~valuewr;
	else if ((cont % 5) == 2) valuewr = (rand() % 0xFFFF);
	else if ((cont % 5) == 3) valuewr = cont;
	else if ((cont % 5) == 4) valuewr = writeval;
	//	printf("FEC %d CHIP%d VALUE %X\n",fec,j,valuewr);
	valuewr &= 0x7F;
	bfnpt[j] = valuewr;
	bfnptwr = 1;
	if ((ret = saltroWriteRegister(srus.controlsocket,&srus.sruserver,0,fec,j,0,0x0C,valuewr)) != 0) {
	  ret1bfnpt++;
	  ret1++;
	  bfnptwr = 0;
	}
	// PMADD
	valuewr = (j << 3) + 5;
	if ((cont % 5) == 1)  valuewr = ~valuewr;
	else if ((cont % 5) == 2) valuewr = (rand() % 0xFFFFF);
	else if ((cont % 5) == 3) valuewr = cont;
	else if ((cont % 5) == 4) valuewr = writeval;
	valuewr &= 0x3FF;
	pmadd[j] = valuewr;
	pmaddwr = 1;
	if ((ret = saltroWriteRegister(srus.controlsocket,&srus.sruserver,0,fec,j,0,0x0D,valuewr)) != 0) {
	  ret1pmadd++;
	  ret1++;
	  pmaddwr = 0;
	}
	// BC1THR
	valuewr = (j << 3) + 2;
	if ((cont % 5) == 1)  valuewr = ~valuewr;
	else if ((cont % 5) == 2) valuewr = (rand() % 0xFFFFF);
	else if ((cont % 5) == 3) valuewr = cont;
	else if ((cont % 5) == 4) valuewr = writeval;
	valuewr &= 0x3FFF;
	bc1thr[j] = valuewr;
	bc1thrwr = 1;
	if ((ret = saltroWriteRegister(srus.controlsocket,&srus.sruserver,0,fec,j,0,0x0E,valuewr)) != 0) {
	  ret1bc1thr++;
	  ret1++;
	  bc1thrwr = 0;
	}

	// Channel registers
	for (k = 0; k < 16; k++) {
	  if (( mychan & ( 1 << k)) != 0) {
	    ch = j * 16 + k;
	    // K1
	    valuewr = (j << 7) + (k << 3) + 0;
	    if ((cont % 5) == 1)  valuewr = ~valuewr;
	    else if ((cont % 5) == 2) valuewr = (rand() % 0xFFFFF);
	    else if ((cont % 5) == 3) valuewr = cont;
	    else if ((cont % 5) == 4) valuewr = writeval;
	    valuewr &= 0x1FFF;
	    k1[ch] = valuewr;
	    k1wr[ch] = 1;
	    if ((ret = saltroWriteRegister(srus.controlsocket,&srus.sruserver,0,fec,j,k,0x00,valuewr)) != 0) {
	      ret1k1[ch]++;
	      ret1++;
	      k1wr[ch] = 0;
	    }
	    // K2
	    valuewr = (j << 7) + (k << 3) + 1;
	    if ((cont % 5) == 1)  valuewr = ~valuewr;
	    else if ((cont % 5) == 2) valuewr = (rand() % 0xFFFFF);
	    else if ((cont % 5) == 3) valuewr = cont;
	    else if ((cont % 5) == 4) valuewr = writeval;
	    valuewr &= 0x1FFF;
	    k2[ch] = valuewr;
	    k2wr[ch] = 1;
	    if ((ret = saltroWriteRegister(srus.controlsocket,&srus.sruserver,0,fec,j,k,0x01,valuewr)) != 0) {
	      ret1k2[ch]++;
	      ret1++;
	      k2wr[ch] = 0;
	    }
	    // K3
	    valuewr = (j << 7) + (k << 3) + 2;
	    if ((cont % 5) == 1)  valuewr = ~valuewr;
	    else if ((cont % 5) == 2) valuewr = (rand() % 0xFFFFF);
	    else if ((cont % 5) == 3) valuewr = cont;
	    else if ((cont % 5) == 4) valuewr = writeval;
	    valuewr &= 0x1FFF;
	    k3[ch] = valuewr;
	    k3wr[ch] = 1;
	    if ((ret = saltroWriteRegister(srus.controlsocket,&srus.sruserver,0,fec,j,k,0x02,valuewr)) != 0) {
	      ret1k3[ch]++;
	      ret1++;
	      k3wr[ch] = 0;
	    }
	    // K4
	    valuewr = (j << 7) + (k << 3) + 3;
	    if ((cont % 5) == 1)  valuewr = ~valuewr;
	    else if ((cont % 5) == 2) valuewr = (rand() % 0xFFFFF);
	    else if ((cont % 5) == 3) valuewr = cont;
	    else if ((cont % 5) == 4) valuewr = writeval;
	    valuewr &= 0x1FFF;
	    k4[ch] = valuewr;
	    k4wr[ch] = 1;
	    if ((ret = saltroWriteRegister(srus.controlsocket,&srus.sruserver,0,fec,j,k,0x03,valuewr)) != 0) {
	      ret1k4[ch]++;
	      ret1++;
	      k4wr[ch] = 0;
	    }
	    // L1
	    valuewr = (j << 7) + (k << 3) + 4;
	    if ((cont % 5) == 1)  valuewr = ~valuewr;
	    else if ((cont % 5) == 2) valuewr = (rand() % 0xFFFFF);
	    else if ((cont % 5) == 3) valuewr = cont;
	    else if ((cont % 5) == 4) valuewr = writeval;
	    valuewr &= 0x1FFF;
	    l1[ch] = valuewr;
	    l1wr[ch] = 1;
	    if ((ret = saltroWriteRegister(srus.controlsocket,&srus.sruserver,0,fec,j,k,0x04,valuewr)) != 0) {
	      ret1l1[ch]++;
	      ret1++;
	      l1wr[ch] = 0;
	    }
	    // L2
	    valuewr = (j << 7) + (k << 3) + 5;
	    if ((cont % 5) == 1)  valuewr = ~valuewr;
	    else if ((cont % 5) == 2) valuewr = (rand() % 0xFFFFF);
	    else if ((cont % 5) == 3) valuewr = cont;
	    else if ((cont % 5) == 4) valuewr = writeval;
	    valuewr &= 0x1FFF;
	    l2[ch] = valuewr;
	    l2wr[ch] = 1;
	    if ((ret = saltroWriteRegister(srus.controlsocket,&srus.sruserver,0,fec,j,k,0x05,valuewr)) != 0) {
	      ret1l2[ch]++;
	      ret1++;
	      l2wr[ch] = 0;
	    }
	    // L3
	    valuewr = (j << 7) + (k << 3) + 6;
	    if ((cont % 5) == 1)  valuewr = ~valuewr;
	    else if ((cont % 5) == 2) valuewr = (rand() % 0xFFFFF);
	    else if ((cont % 5) == 3) valuewr = cont;
	    else if ((cont % 5) == 4) valuewr = writeval;
	    valuewr &= 0x1FFF;
	    l3[ch] = valuewr;
	    l3wr[ch] = 1;
	    if ((ret = saltroWriteRegister(srus.controlsocket,&srus.sruserver,0,fec,j,k,0x06,valuewr)) != 0) {
	      ret1l3[ch]++;
	      ret1++;
	      l3wr[ch] = 0;
	    }
	    // L4
	    valuewr = (j << 7) + (k << 3) + 7;
	    if ((cont % 5) == 1)  valuewr = ~valuewr;
	    else if ((cont % 5) == 2) valuewr = (rand() % 0xFFFFF);
	    else if ((cont % 5) == 3) valuewr = cont;
	    else if ((cont % 5) == 4) valuewr = writeval;
	    valuewr &= 0x1FFF;
	    l4[ch] = valuewr;
	    l4wr[ch] = 1;
	    if ((ret = saltroWriteRegister(srus.controlsocket,&srus.sruserver,0,fec,j,k,0x07,valuewr)) != 0) {
	      ret1l4[ch]++;
	      ret1++;
	      l4wr[ch] = 0;
	    }
	    // ZSTHR
	    valuewr = (j << 3) + 1;
	    if ((cont % 5) == 1)  valuewr = ~valuewr;
	    else if ((cont % 5) == 2) valuewr = (rand() % 0xFFFFF);
	    else if ((cont % 5) == 3) valuewr = cont;
	    else if ((cont % 5) == 4) valuewr = writeval;
	    valuewr &= 0xFFFFF;
	    zsthr[ch] = valuewr;
	    zsthrwr[ch] = 1;
	    if ((ret = saltroWriteRegister(srus.controlsocket,&srus.sruserver,0,fec,j,k,0x08,valuewr)) != 0) {
	      ret1zsthr[ch]++;
	      ret1++;
	      zsthrwr[ch] = 0;
	    }
	    // VFPED
	    valuewr = (j << 7) + (k << 3) + 6;
	    if ((cont % 5) == 1)  valuewr = ~valuewr;
	    else if ((cont % 5) == 2) valuewr = (rand() % 0xFFFFF);
	    else if ((cont % 5) == 3) valuewr = cont;
	    else if ((cont % 5) == 4) valuewr = writeval;
	    valuewr &= 0x3FF;
	    vfped[ch] = valuewr;
	    vfpedwr[ch] = 1;
	    if ((ret = saltroWriteRegister(srus.controlsocket,&srus.sruserver,0,fec,j,k,0x13,valuewr)) != 0) {
	      ret1vfped[ch]++;
	      ret1++;
	      vfpedwr[ch] = 0;
	    }
	    // PMDTA
	    /* can not be tested - do not read register value but memory data
	     */
	    // CTE
	    valuewr = (j << 7) + (k << 3) + 6;
	    if ((cont % 5) == 1)  valuewr = ~valuewr;
	    else if ((cont % 5) == 2) valuewr = (rand() % 0xFFFFF);
	    else if ((cont % 5) == 3) valuewr = cont;
	    else if ((cont % 5) == 4) valuewr = writeval;
	    valuewr &= 0x3FF;
	    cte[ch] = valuewr;
	    ctewr[ch] = 1;
	    if ((ret = saltroWriteRegister(srus.controlsocket,&srus.sruserver,0,fec,j,k,0x15,valuewr)) != 0) {
	      ret1cte[ch]++;
	      ret1++;
	      ctewr[ch] = 0;
	    }
	  }
	}
      }
      /*
      if (ret1 != 0) {
	printf("Errors in saltroWriteRegister\n");
	printf("We exit test\n");
	signal_stop = 1;
      }
      */
      //READ & CHECK REGISTERS
      if (signal_stop == 0) {
	for (j = chip; j <=chip; j++) {
	  // Global registers
	  // BFNPT
	  if (bfnptwr != 0) {
	    if ((ret = saltroReadRegister(srus.controlsocket,&srus.sruserver,fec,j,0,0x0C,&valuerd)) != 0) {
	      ret2bfnpt++;
	      ret2++;
	    }
	    else {
	      nbrdbfnpt++;
	      valuerd &= 0x7F;
	      if (cmpreg(fec,j,0,0x0C,valuerd,bfnpt[j],verify)) {
		nberr++;
		errbfnpt[j]++;
	      }
	    }
	  }
	  // BC2THR
	  if (bc2thrwr != 0) {
	    if ((ret = saltroReadRegister(srus.controlsocket,&srus.sruserver,fec,j,0,0x09,&valuerd)) != 0) {
	      ret2bc2thr++;
	      ret2++;
	    }
	    else {
	      nbrdbc2thr++;
	      valuerd &= 0xFFFFF;
	      if (cmpreg(fec,j,0,0x09,valuerd,bc2thr[j],verify)) {
		nberr++;
		errbc2thr[j]++;
	      }
	    }
	  }
	  // TRCFG
	  if (trcfgwr != 0) {
	    if ((ret = saltroReadRegister(srus.controlsocket,&srus.sruserver,fec,j,0,0x0A,&valuerd)) != 0) {
	      ret2trcfg++;
	      ret2++;
	    }
	    
	    else {
	      nbrdtrcfg++;
	      valuerd &= 0xFFFFF;
	      if (cmpreg(fec,j,0,0x0A,valuerd,trcfg[j],verify)) {
		nberr++;	    
		errtrcfg[j]++;
	      }
	    }
	  }
	  // DPCFG
	  if (dpcfgwr != 0) {
	    if ((ret = saltroReadRegister(srus.controlsocket,&srus.sruserver,fec,j,0,0x0B,&valuerd)) != 0) {
	      ret2dpcfg++;
	      ret2++;
	    }
	    else {
	      nbrddpcfg++;
	      valuerd &= 0x7FFFF;
	      if (cmpreg(fec,j,0,0x0B,valuerd,dpcfg[j],verify)) {
		nberr++;
		errdpcfg[j]++;
	      }
	    }
	  }
	  // PMADD
	  if (pmaddwr != 0) {
	    if ((ret = saltroReadRegister(srus.controlsocket,&srus.sruserver,fec,j,0,0x0D,&valuerd)) != 0) {
	      ret2pmadd++;
	      ret2++;
	    }
	    else {
	      nbrdpmadd++;
	      valuerd &= 0x3FF;
	      if (cmpreg(fec,j,0,0x0D,valuerd,pmadd[j],verify)) {
		nberr++;
		errpmadd[j]++;
	      }
	    }
	  }
	  // BC1THR
	  if (bc1thrwr != 0) {
	    if ((ret = saltroReadRegister(srus.controlsocket,&srus.sruserver,fec,j,0,0x0E,&valuerd)) != 0) {
	      ret2bc1thr++;
	      ret2++;
	    }
	    else {
	      nbrdbc1thr++;
	      valuerd &= 0x3FFF;
	      if (cmpreg(fec,j,0,0x0E,valuerd,bc1thr[j],verify)) {
		nberr++;
		errbc1thr[j]++;
	      }
	    }
	  }
	  
	  // Channel registers
	  for (k = 0; k < 16; k++) {
	    if ((mychan & ( 1 << k )) != 0) {
	      ch = j * 16 + k;
	      // K1
	      if (k1wr[ch] != 0) {
		if ((ret = saltroReadRegister(srus.controlsocket,&srus.sruserver,fec,j,k,0x00,&valuerd)) != 0) {
		  ret2k1[ch]++;
		  ret2++;
		}
		else {
		  nbrdk1[ch]++;
		  valuerd &= 0x1FFF;
		  if (cmpreg(fec,j,k,0x00,valuerd,k1[ch],verify)) {
		    nberr++;
		    errk1[ch]++;
		  }
		}
	      }
	      // K2
	      if (k2wr[ch] != 0) {
		if ((ret = saltroReadRegister(srus.controlsocket,&srus.sruserver,fec,j,k,0x01,&valuerd)) != 0) {
		  ret2k2[ch]++;
		  ret2++;
		}
		else {
		  nbrdk2[ch]++;
		  valuerd &= 0x1FFF;
		  if (cmpreg(fec,j,k,0x01,valuerd,k2[ch],verify)) {
		    nberr++;
		    errk2[ch]++;
		  }
		}
	      }
	      // K3
	      if (k3wr[ch] != 0) {
		if ((ret = saltroReadRegister(srus.controlsocket,&srus.sruserver,fec,j,k,0x02,&valuerd)) != 0) {
		  ret2k3[ch]++;
		  ret2++;
		}
		else {
		  nbrdk3[ch]++;
		  valuerd &= 0x1FFF;
		  if (cmpreg(fec,j,k,0x02,valuerd,k3[ch],verify)) {
		    nberr++;
		    errk3[ch]++;
		  }
		}
	      }
	      // K4
	      if (k4wr[ch] != 0) {
		if ((ret = saltroReadRegister(srus.controlsocket,&srus.sruserver,fec,j,k,0x03,&valuerd)) != 0) {
		  ret2k4[ch]++;
		  ret2++;
		}
		else {
		  nbrdk4[ch]++;
		  valuerd &= 0x1FFF;
		  if (cmpreg(fec,j,k,0x03,valuerd,k4[ch],verify)) {
		    nberr++;
		    errk4[ch]++;
		  }
		}
	      }
	      // L1
	      if (l1wr[ch] != 0) {
		if ((ret = saltroReadRegister(srus.controlsocket,&srus.sruserver,fec,j,k,0x04,&valuerd)) != 0) {
		  ret2l1[ch]++;
		  ret2++;
		}
		else {
		  nbrdl1[ch]++;
		  valuerd &= 0x1FFF;
		  if (cmpreg(fec,j,k,0x04,valuerd,l1[ch],verify)) {
		    nberr++;
		    errl1[ch]++;
		  }
		}
	      }
	      // L2
	      if (l2wr[ch] != 0) {
		if ((ret = saltroReadRegister(srus.controlsocket,&srus.sruserver,fec,j,k,0x05,&valuerd)) != 0) {
		  ret2l2[ch]++;
		  ret2++;
		}
		else {
		  nbrdl2[ch]++;
		  valuerd &= 0x1FFF;
		  if (cmpreg(fec,j,k,0x05,valuerd,l2[ch],verify)) {
		    nberr++;
		    errl2[ch]++;
		  }
		}
	      }
	      // L3
	      if (l3wr[ch] != 0) {
		if ((ret = saltroReadRegister(srus.controlsocket,&srus.sruserver,fec,j,k,0x06,&valuerd)) != 0) {
		  ret2l3[ch]++;
		  ret2++;
		}
		else {
		  nbrdl3[ch]++;
		  valuerd &= 0x1FFF;
		  if (cmpreg(fec,j,k,0x06,valuerd,l3[ch],verify)) {
		    nberr++;
		    errl3[ch]++;
		  }
		}
	      }
	      // L4
	      if (l4wr[ch] != 0) {
		if ((ret = saltroReadRegister(srus.controlsocket,&srus.sruserver,fec,j,k,0x07,&valuerd)) != 0) {
		  ret2l4[ch]++;
		  ret2++;
		}
		else {
		  nbrdl4[ch]++;
		  valuerd &= 0x1FFF;
		  if (cmpreg(fec,j,k,0x07,valuerd,l4[ch],verify)) {
		    nberr++;
		    errl4[ch]++;
		  }
		}
	      }
	      // ZSTHR
	      if (zsthrwr[ch] != 0) {
		if (( ret = saltroReadRegister(srus.controlsocket,&srus.sruserver,fec,j,k,0x08,&valuerd)) != 0) {
		  ret2zsthr[ch]++;
		  ret2++;
		}
		else {
		  nbrdzsthr[ch]++;
		  valuerd &= 0xFFFFF;
		  if (cmpreg(fec,j,k,0x08,valuerd,zsthr[ch],verify)) {
		    nberr++;
		    errzsthr[ch]++;
		  }
		}
	      }
	      // VFPED
	      if (vfpedwr[ch] != 0) {
		if ((ret = saltroReadRegister(srus.controlsocket,&srus.sruserver,fec,j,k,0x13,&valuerd)) != 0) {
		  ret2vfped[ch]++;
		  ret2++;
		}
		else {
		  nbrdvfped[ch]++;
		  valuerd &= 0x3FF;
		  if (cmpreg(fec,j,k,0x13,valuerd,vfped[ch],verify)) {
		    nberr++;
		    errvfped[ch]++;
		  }
		}
	      }
	      // PMDTA
	      /*
	       */
	      // CTE
	      if (ctewr[ch] != 0) {
		if ((ret = saltroReadRegister(srus.controlsocket,&srus.sruserver,fec,j,k,0x15,&valuerd)) != 0) {
		  ret2cte[ch]++;
		  ret2++;
		}
		else {
		  nbrdcte[ch]++;
		  valuerd &= 0x3FF;
		  if (cmpreg(fec,j,k,0x15,valuerd,cte[ch],verify)) {
		    nberr++;
		    errcte[ch]++;
		  }
		}
	      }
	    }
	  }
	  /*
	  if (ret2 != 0) {
	    printf("Errors in saltroReadRegister\n");
	    printf("We exit test\n");
	    signal_stop = 1;
	  }
	  */
	}
      }
      cont++;
      if ((cont % 100) == 0) { printf("LOOP %8d\r",cont); fflush(stdout);}


      if (--loop == 0) cont = 0;
      if (loop < 0) loop = 0;
      if (signal_stop) cont = 0;
    } 

    printf("\nEXIT Number of errors %d %d %d\n",nberr,ret1,ret2);
    
    if (logdata != 0) {
      struct stat   fileBuffer;
      int csvexist = 0;
      if (stat (csvfile, &fileBuffer) == 0) csvexist = 1;
      printf("CSV EXIST %d\n",csvexist);
      fcsv = fopen(csvfile,"a");
      if (fcsv == NULL) {
	return 3;
      }
      
      if (csvexist == 0) {
	fprintf(fcsv,"Register,Global,Ret1,Ret2,NbRd,");
	for (int j = 0; j < 16; j++) {
	  ch = chip*16 + j;
	  fprintf(fcsv,"Ch%d,Ret1,Ret2,NbRd,",ch);
	}
	fprintf(fcsv,"\n");
      }
      fprintf(fcsv,"BC1THR,%d,%d,%d,%d,",errbc1thr[chip],ret1bc1thr,ret2bc1thr,nbrdbc1thr);
      for (int j = 0; j < 16; j++) fprintf(fcsv,"0,0,0,0,");
      fprintf(fcsv,"\n");
      fprintf(fcsv,"BC2THR,%d,%d,%d,%d,",errbc2thr[chip],ret1bc2thr,ret2bc2thr,nbrdbc2thr);
      for (int j = 0; j < 16; j++) fprintf(fcsv,"0,0,0,0,");
      fprintf(fcsv,"\n");
      fprintf(fcsv,"BFNPT,%d,%d,%d,%d,",errbfnpt[chip],ret1bfnpt,ret2bfnpt,nbrdbfnpt);
      for (int j = 0; j < 16; j++) fprintf(fcsv,"0,0,0,0,");
      fprintf(fcsv,"\n");
      fprintf(fcsv,"DPCFG,%d,%d,%d,%d,",errdpcfg[chip],ret1dpcfg,ret2dpcfg,nbrddpcfg);
      for (int j = 0; j < 16; j++) fprintf(fcsv,"0,0,0,0,");
      fprintf(fcsv,"\n");
      fprintf(fcsv,"TRCFG,%d,%d,%d,%d,",errtrcfg[chip],ret1trcfg,ret2trcfg,nbrdtrcfg);
      for (int j = 0; j < 16; j++) fprintf(fcsv,"0,0,0,0,");
      fprintf(fcsv,"\n");
      fprintf(fcsv,"PMADD,%d,%d,%d,%d,",errpmadd[chip],ret1pmadd,ret2pmadd,nbrdpmadd);
      for (int j = 0; j < 16; j++) fprintf(fcsv,"0,0,0,0,");
      fprintf(fcsv,"\n");
      int j1 = chip * 16;
      int j2 = j1 + 16;
      fprintf(fcsv,"K1,0,0,0,0,");
      for (int j = j1; j < j2; j++) fprintf(fcsv,"%d,%d,%d,%d,",errk1[j],ret1k1[j],ret2k1[j],nbrdk1[j]);
      fprintf(fcsv,"\n");
      fprintf(fcsv,"K2,0,0,0,0,");
      for (int j = j1; j < j2; j++) fprintf(fcsv,"%d,%d,%d,%d,",errk2[j],ret1k2[j],ret2k2[j],nbrdk2[j]);
      fprintf(fcsv,"\n");
      fprintf(fcsv,"K3,0,0,0,0,");
      for (int j = j1; j < j2; j++) fprintf(fcsv,"%d,%d,%d,%d,",errk3[j],ret1k3[j],ret2k3[j],nbrdk3[j]);
      fprintf(fcsv,"\n");
      fprintf(fcsv,"K4,0,0,0,0,");
      for (int j = j1; j < j2; j++) fprintf(fcsv,"%d,%d,%d,%d,",errk4[j],ret1k4[j],ret2k4[j],nbrdk4[j]);
      fprintf(fcsv,"\n");
      fprintf(fcsv,"L1,0,0,0,0,");
      for (int j = j1; j < j2; j++) fprintf(fcsv,"%d,%d,%d,%d,",errl1[j],ret1l1[j],ret2l1[j],nbrdl1[j]);
      fprintf(fcsv,"\n");
      fprintf(fcsv,"L2,0,0,0,0,");
      for (int j = j1; j < j2; j++) fprintf(fcsv,"%d,%d,%d,%d,",errl2[j],ret1l2[j],ret2l2[j],nbrdl2[j]);
      fprintf(fcsv,"\n");
      fprintf(fcsv,"L3,0,0,0,0,");
      for (int j = j1; j < j2; j++) fprintf(fcsv,"%d,%d,%d,%d,",errl3[j],ret1l3[j],ret2l3[j],nbrdl3[j]);
      fprintf(fcsv,"\n");
      fprintf(fcsv,"L4,0,0,0,0,");
      for (int j = j1; j < j2; j++) fprintf(fcsv,"%d,%d,%d,%d,",errl4[j],ret1l4[j],ret2l4[j],nbrdl4[j]);
      fprintf(fcsv,"\n");
      fprintf(fcsv,"ZSTHR,0,0,0,0,");
      for (int j = j1; j < j2; j++) fprintf(fcsv,"%d,%d,%d,%d,",errzsthr[j],ret1zsthr[j],ret2zsthr[j],nbrdzsthr[j]);
      fprintf(fcsv,"\n");
      fprintf(fcsv,"VFPED,0,0,0,0,");
      for (int j = j1; j < j2; j++) fprintf(fcsv,"%d,%d,%d,%d,",errvfped[j],ret1vfped[j],ret2vfped[j],nbrdvfped[j]);
      fprintf(fcsv,"\n");
      fprintf(fcsv,"CTE,0,0,0,0,");
      for (int j = j1; j < j2; j++) fprintf(fcsv,"%d,%d,%d,%d,",errcte[j],ret1cte[j],ret2cte[j],nbrdcte[j]);
      fprintf(fcsv,"\n");
      fclose(fcsv);	
    }
    else {
      printf("FILE: %s not opened\n",csvfile);
      return (1);
    }

    return 0;
}