--- yoda/techmodel/forroutines/anticounter/AC.c	2004/10/17 12:42:54	2.1
+++ yoda/techmodel/forroutines/anticounter/AC.c	2006/02/07 17:11:10	6.0
@@ -1,180 +1,273 @@
-/*****************************************************************
-Function to read AC physics data v1.1
+/*******************************v1.3********************************
+
+Functions to read AC physics data (ACphysics) and AC calibration
+data (ACcalib).
 Author: Petter Hofverberg, petter@particle.kth.se
 
-0408 v1.0 alive
-0409 Added shifting operators to fix problem with odd data (BBAC|11DD)
-                                                              -----
+0410 v1.0 alive
+0412 v1.1 fixed problem with found, and changed headers
+0502 v1.2 added a crc check
+0502 v1.3 increased buffer size
+
 Errors: (returned to the main program as the variable "err")
 err=
-0 - Ok
-1 - Data found, but corrupt
-2 - Data dont found in buffer
+0xFF - data (physics or calibration) from both cards found
+0xF0 - only data from main card found
+0x0F - only data from extra card found
+0x00 - no data found
 
-ToDo: i)  do it endian-independent
-      ii) check for more events in the same file?
+CRCcheck:  1 - OK, 0 - error
 ******************************************************************/
 
 #include <stdio.h>
 #include "AC.h"
+#define TRUE 1
+#define FALSE 0
 
-int i,err,found,j;
-//unsigned short buffer[1000];
-//unsigned short tmp1,tmp2;
-unsigned short buffer[1000];
-unsigned short tmp1;
+int i,j,found;
+unsigned short buffer[8300];
+unsigned short tmp1,tmp2,check;
+unsigned char err;
 
-struct physicsstruct physicsdata;
+struct physicsstruct physicsdata[2];
 struct physicsstruct *physicspointer;
 
 struct calibstruct calibdata;
 struct calibstruct *calibpointer;
 
 
-//int ACphysics(int length,unsigned short* datapointer,struct physicsstruct* physicspointer)
-int ACphysics(int length,unsigned char* datapointer,struct physicsstruct* physicspointer)
+//CRC check function
+short crc(short old,short new)
+{
+  union crc_data {
+    short word;
+    struct bit_field {
+      unsigned b0:1;
+      unsigned b1:1;
+      unsigned b2:1;
+      unsigned b3:1;
+      unsigned b4:1;
+      unsigned b5:1;
+      unsigned b6:1;
+      unsigned b7:1;
+      unsigned b8:1;
+      unsigned b9:1;
+      unsigned b10:1;
+      unsigned b11:1;
+      unsigned b12:1;
+      unsigned b13:1;
+      unsigned b14:1;
+      unsigned b15:1;
+    } bit;
+  } c,d,r;
+
+  c.word = old;
+  d.word = new;
+  r.word = 0;
+
+  r.bit.b0 = c.bit.b0 ^ c.bit.b4 ^ c.bit.b8 ^ c.bit.b11 ^ c.bit.b12 ^
+             d.bit.b0 ^ d.bit.b4 ^ d.bit.b8 ^ d.bit.b11 ^ d.bit.b12;
+
+  r.bit.b1 = c.bit.b1 ^ c.bit.b5 ^ c.bit.b9 ^ c.bit.b12 ^ c.bit.b13 ^
+             d.bit.b1 ^ d.bit.b5 ^ d.bit.b9 ^ d.bit.b12 ^ d.bit.b13;
+
+  r.bit.b2 = c.bit.b2 ^ c.bit.b6 ^ c.bit.b10 ^ c.bit.b13 ^ c.bit.b14 ^
+             d.bit.b2 ^ d.bit.b6 ^ d.bit.b10 ^ d.bit.b13 ^ d.bit.b14;
+
+  r.bit.b3 = c.bit.b3 ^ c.bit.b7 ^ c.bit.b11 ^ c.bit.b14 ^ c.bit.b15 ^
+             d.bit.b3 ^ d.bit.b7 ^ d.bit.b11 ^ d.bit.b14 ^ d.bit.b15;
+
+  r.bit.b4 = c.bit.b4 ^ c.bit.b8 ^ c.bit.b12 ^ c.bit.b15 ^
+             d.bit.b4 ^ d.bit.b8 ^ d.bit.b12 ^ d.bit.b15;
+
+  r.bit.b5 = c.bit.b0 ^ c.bit.b4 ^ c.bit.b5 ^ c.bit.b8 ^ c.bit.b9 ^
+             c.bit.b11 ^ c.bit.b12 ^ c.bit.b13 ^
+             d.bit.b0 ^ d.bit.b4 ^ d.bit.b5 ^ d.bit.b8 ^ d.bit.b9 ^
+             d.bit.b11 ^ d.bit.b12 ^ d.bit.b13;
+
+  r.bit.b6 = c.bit.b1 ^ c.bit.b5 ^ c.bit.b6 ^ c.bit.b9 ^ c.bit.b10 ^
+             c.bit.b12 ^ c.bit.b13 ^ c.bit.b14 ^
+             d.bit.b1 ^ d.bit.b5 ^ d.bit.b6 ^ d.bit.b9 ^ d.bit.b10 ^
+             d.bit.b12 ^ d.bit.b13 ^ d.bit.b14;
+
+  r.bit.b7 = c.bit.b2 ^ c.bit.b6 ^ c.bit.b7 ^ c.bit.b10 ^ c.bit.b11 ^
+             c.bit.b13 ^ c.bit.b14 ^ c.bit.b15 ^
+             d.bit.b2 ^ d.bit.b6 ^ d.bit.b7 ^ d.bit.b10 ^ d.bit.b11 ^
+             d.bit.b13 ^ d.bit.b14 ^ d.bit.b15;
+
+  r.bit.b8 = c.bit.b3 ^ c.bit.b7 ^ c.bit.b8 ^ c.bit.b11 ^ c.bit.b12 ^
+             c.bit.b14 ^ c.bit.b15 ^
+             d.bit.b3 ^ d.bit.b7 ^ d.bit.b8 ^ d.bit.b11 ^ d.bit.b12 ^
+             d.bit.b14 ^ d.bit.b15;
+
+  r.bit.b9 = c.bit.b4 ^ c.bit.b8 ^ c.bit.b9 ^ c.bit.b12 ^ c.bit.b13 ^
+             c.bit.b15 ^
+             d.bit.b4 ^ d.bit.b8 ^ d.bit.b9 ^ d.bit.b12 ^ d.bit.b13 ^
+             d.bit.b15;
+
+  r.bit.b10 = c.bit.b5 ^ c.bit.b9 ^ c.bit.b10 ^ c.bit.b13 ^ c.bit.b14 ^
+              d.bit.b5 ^ d.bit.b9 ^ d.bit.b10 ^ d.bit.b13 ^ d.bit.b14;
+
+  r.bit.b11 = c.bit.b6 ^ c.bit.b10 ^ c.bit.b11 ^ c.bit.b14 ^ c.bit.b15 ^
+              d.bit.b6 ^ d.bit.b10 ^ d.bit.b11 ^ d.bit.b14 ^ d.bit.b15;
+
+  r.bit.b12 = c.bit.b0 ^ c.bit.b4 ^ c.bit.b7 ^ c.bit.b8 ^ c.bit.b15 ^
+              d.bit.b0 ^ d.bit.b4 ^ d.bit.b7 ^ d.bit.b8 ^ d.bit.b15;
+
+  r.bit.b13 = c.bit.b1 ^ c.bit.b5 ^ c.bit.b8 ^ c.bit.b9 ^
+              d.bit.b1 ^ d.bit.b5 ^ d.bit.b8 ^ d.bit.b9;
+
+  r.bit.b14 = c.bit.b2 ^ c.bit.b6 ^ c.bit.b9 ^ c.bit.b10 ^
+              d.bit.b2 ^ d.bit.b6 ^ d.bit.b9 ^ d.bit.b10;
+
+  r.bit.b15 = c.bit.b3 ^ c.bit.b7 ^ c.bit.b10 ^ c.bit.b11 ^
+              d.bit.b3 ^ d.bit.b7 ^ d.bit.b10 ^ d.bit.b11;
+
+  return r.word;
+}
+
+
+//Fill physicsdata from buffer
+void fillphys(int k,unsigned short *buff)
 {
+  for(i=0;i<2;i++) physicsdata[k].header[i]=buff[i];
+  physicsdata[k].status=buff[2];
+  physicsdata[k].hitmap=buff[3];
+  for(i=0;i<6;i++) physicsdata[k].regist[i]=buff[4+i];
+  for(i=0;i<16;i++) physicsdata[k].shift[i]=buff[10+i];
+  for(i=0;i<16;i++) physicsdata[k].counters[i]=buff[26+i];
+  for(i=0;i<8;i++) physicsdata[k].coinc[i]=buff[42+i];
+  physicsdata[k].trigg=buff[50];
+  for(i=0;i<2;i++) physicsdata[k].clock[i]=buff[51+i];
+  for(i=0;i<2;i++) physicsdata[k].temp[i]=buff[53+i];
+  for(i=0;i<8;i++) physicsdata[k].DAC[i]=buff[55+i];
+  physicsdata[k].CRC=buff[63];
+  if(check==physicsdata[k].CRC)
+    physicsdata[k].CRCcheck=TRUE;
+  else
+    physicsdata[k].CRCcheck=FALSE;
+}
 
- int iter=2;
+//Fill calibdata from buffer
+void fillcalib(unsigned short *buff)
+{
+  for(i=0;i<2;i++) calibdata.header[i]=buff[i];
+  for(i=0;i<5;i++) calibdata.status[i]=buff[2+i];
+  for(i=0;i<8;i++) calibdata.temp[i]=buff[7+i];
+  for(i=0;i<8;i++) calibdata.DAC1[i]=buff[15+i];
+  for(i=0;i<8;i++) calibdata.DAC2[i]=buff[23+i];
+  for(i=0;i<6;i++) calibdata.regist[i]=buff[31+i];
+  for(i=0;i<8;i++) calibdata.time[i]=buff[37+i];
+  calibdata.n_tr=buff[45];
+  for(i=0;i<16;i++) calibdata.hitmap_tr[i]=buff[46+i];
+  for(i=0;i<4096;i++) calibdata.curve1[i]=buff[62+i];
+  for(i=0;i<4096;i++) calibdata.curve2[i]=buff[4158+i];
+  calibdata.iCRC=buff[8254];
+  calibdata.tail=buff[8255];
+  calibdata.CRC=buff[8256];
+  if(check==calibdata.CRC)
+    calibdata.CRCcheck=TRUE;
+  else
+    calibdata.CRCcheck=FALSE;
+}
 
-  *physicspointer=physicsdata; 
+unsigned char ACphysics(int length,unsigned char* datapointer,struct physicsstruct* physicspointer)
+{
 
-  //look for header AC11, then cut out the event to a temp buffer
-  while(found==0 && iter<length)
+  err=0;
+  found=0;
+  check=0;
+  int iter=2;
+  for(i=0;i<8300;i++)
+    buffer[i]=0;
+  fillphys(0,&buffer[0]);
+  fillphys(1,&buffer[0]);
+
+  //look for top header ACAC, then unpack data to main card buffer or extra card buffer depending on the subheader
+  //AC11 for main, AC22 for extra
+  while(found<2 && iter<length)
     {
       tmp1 = ((*datapointer) << 8) | *(datapointer+1);
-      
-      if(tmp1==0xAC11)
-      //if(tmp1==0xAC11) //flipped
+      tmp2 = ((*(datapointer+2)) << 8) | *(datapointer+3);
+      if(tmp1 == 0xACAC && ((tmp2 == 0xAC11 && (err&0xF0)==0x0) || (tmp2 == 0xAC22 && (err&0x0F)==0x0)))
 	{ 
-	  found=1;
 	  for(i=0;i<64;i++)
 	    {
 	      buffer[i]=((*datapointer) << 8) | *(datapointer+1);
+	      if(i<63)
+		check=crc(check,buffer[i]);
 	      datapointer=datapointer+2;
 	    }
-	  tmp1=0x0000;
+	  if(tmp2==0xAC11){          //main card
+	    fillphys(0,&buffer[0]);
+	    err |= 0xF0;
+	  }
+	  else{                      //extra card
+	    fillphys(1,&buffer[0]);
+	    err |= 0x0F;
+	  } 
+	  tmp1=tmp2=0x0000;
+	  check=0x0;
+	  found++;
 	}
       else{
 	datapointer++;
 	iter=iter+1;}
     }
-  
-  //check errors
-  if(found==0)
-    err=2;
-  else if(buffer[1]==0x22AC || buffer[1]==0xAC22) 
-    err=0;
-  else
-    err=1;
-
-  //Fill physicsdata from buffer
-  for(i=0;i<2;i++) physicsdata.header[i]=buffer[i];
-  physicsdata.status=buffer[2];
-  physicsdata.hitmap=buffer[3];
-  for(i=0;i<6;i++) physicsdata.regist[i]=buffer[4+i];
-  for(i=0;i<16;i++) physicsdata.shift[i]=buffer[10+i];
-  for(i=0;i<16;i++) physicsdata.counters[i]=buffer[26+i];
-  for(i=0;i<8;i++) physicsdata.coinc[i]=buffer[42+i];
-  physicsdata.trigg=buffer[50];
-  for(i=0;i<2;i++) physicsdata.clock[i]=buffer[51+i];
-  for(i=0;i<2;i++) physicsdata.temp[i]=buffer[53+i];
-  for(i=0;i<8;i++) physicsdata.DAC[i]=buffer[55+i];
-  physicsdata.CRC=buffer[63];
+  //point struct-pointer to physicsdata
+  physicspointer[0]=physicsdata[0];  //card1
+  physicspointer[1]=physicsdata[1];  //card2
 
   return err;
 
 }
 
 
-int ACcalib(int length, unsigned char* datapointer, struct calibstruct* calibpointer)
+unsigned char ACcalib(int length, unsigned char* datapointer, struct calibstruct* calibpointer)
 {
 
+  err=0;
+  found=0;
+  check=0;
   int iter=2;
-	    
-  //point struct-pointer to calibdata
-  *calibpointer=calibdata;  
-
-  //look for header 0xACCA
-  while(found==0 && iter<length)
+  for(i=0;i<8300;i++)
+    buffer[i]=0;
+  fillcalib(&buffer[0]);
+
+  //look for the top header 0xACCA, then the subheaders 0xAC11 and 0xAC22, and unpack the data
+  //to each card depending on these.
+  while(found<1 && iter<length)
     {
       tmp1 = ((*datapointer) << 8) | *(datapointer+1);
+      tmp2 = ((*(datapointer+2)) << 8) | *(datapointer+3);
       
-      if(tmp1==0xACCA)
+      if(tmp1 == 0xACCA && ((tmp2 == 0xAC11 && (err&0xF0)==0x0) || (tmp2 == 0xACA2 && (err&0x0F)==0x0)))
 	{
-	  found=1;
-	  for(i=0;i<8256;i++)
+	  for(i=0;i<8257;i++)
 	    {
 	      buffer[i]=((*datapointer) << 8) | *(datapointer+1);
+	      if(i<8256) //8257
+		check=crc(check,buffer[i]);
 	      datapointer=datapointer+2;
+	      }
+	  
+	  if(tmp2==0xAC11){          //main
+	    fillcalib(&buffer[0]);
+	    err |= 0xF0;
+	  }
+	  else{                      //extra
+	    fillcalib(&buffer[0]);
+	    err |= 0x0F; 
 	    }
-	  tmp1=0x0000;
+	  tmp1=tmp2=0x0000;
+	  found++;
 	}
       else{
-      datapointer++;
-      iter=iter+1;}
-    }
-
-  //check errors
-  if(found==0)
-    err=2;
-  else if(buffer[8254]==0xAC22)
-    err=0;
-  else
-    err=1;
-
-  printf("length: %d\n iter: %d\n",length,iter);
-
-  //Fill calibdata from buffer
-  calibdata.header=buffer[0];
-  for(i=0;i<5;i++) calibdata.status[i]=buffer[1+i];
-  for(i=0;i<8;i++) calibdata.temp[i]=buffer[6+i];
-  for(i=0;i<8;i++) calibdata.DAC1[i]=buffer[14+i];
-  for(i=0;i<8;i++) calibdata.DAC2[i]=buffer[22+i];
-  for(i=0;i<6;i++) calibdata.regist[i]=buffer[30+i];
-  for(i=0;i<8;i++) calibdata.time[i]=buffer[36+i];
-  calibdata.n_tr=buffer[44];
-  for(i=0;i<16;i++) calibdata.hitmap_tr[i]=buffer[45+i];
-  for(i=0;i<4096;i++) calibdata.curve1[i]=buffer[61+i];
-  for(i=0;i<4096;i++) calibdata.curve2[i]=buffer[4157+i];
-  calibdata.iCRC=buffer[8253];
-  calibdata.tail=buffer[8254];
-  calibdata.CRC=buffer[8255];
-
-  /*  
-  //debug
-  if(err!=2)
-    {
-      printf("header.....   %hx\n",calibdata.header);
-      printf("status.....   %hx\n",calibdata.status[0]);
-      printf("temp.......   %hx\n",calibdata.temp[0]);
-      printf("DAC1.......   %hx\n",calibdata.DAC1[0]);
-      printf("DAC2.......   %hx\n",calibdata.DAC2[0]);
-      printf("regist.....   %hx\n",calibdata.regist[0]);
-      printf("time.......   %hx\n",calibdata.time[0]);
-      printf("n_tr.......   %hx\n",calibdata.n_tr);
-      printf("hitmap_tr..   %hx\n",calibdata.hitmap_tr[0]);
-      printf("curve1.....   %hx\n",calibdata.curve1[0]);
-      printf("curve2.....   %hx\n",calibdata.curve2[0]);
-      printf("iCRC.......   %hx\n",calibdata.iCRC);
-      printf("tail.......   %hx\n",calibdata.tail);
-      printf("CRC........   %hx\n",calibdata.CRC);
+	datapointer++;
+	iter=iter+1;}
     }
-  printf("err: %d\n",err);
-  */
-
+  memcpy(calibpointer,&calibdata,sizeof(calibdata));
+  
   return err;
 }
 
-
-
-//transposing function
-int flip(int i16)
-{
-  int temp;
-  
-  temp = 0;
-  temp |= 0xFF00 & ((0x00FF & i16) << 8);
-  temp |= 0x00FF & ((0xFF00 & i16) >> 8);
-  return temp;
-}