forroutines/anticounter/AC.c

/*******************************v1.0********************************

Functions to read AC physics data (ACphysics) and AC calibration
data (ACcalib).
Author: Petter Hofverberg, petter@particle.kth.se

0410 v1.0 alive

Errors: (returned to the main program as the variable "err")
err=
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

******************************************************************/

#include <stdio.h>
#include "AC.h"

int i,found,j;
unsigned short buffer[1000];
unsigned short tmp1,tmp2;
unsigned char err;

struct physicsstruct physicsdata[2];
struct physicsstruct *physicspointer;

struct calibstruct calibdata[2];
struct calibstruct *calibpointer;


unsigned char ACphysics(int length,unsigned char* datapointer,struct physicsstruct* physicspointer)
{

 int iter=2;
  physicspointer[0]=physicsdata[0];
  physicspointer[1]=physicsdata[1];

  //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);
      tmp2 = ((*(datapointer+2)) << 8) | *(datapointer+3);

      if(tmp1 == 0xAC11 && ((tmp2 == 0xAC11 && (err&0xF0)==0x0) || (tmp2 == 0xAC22 && (err&0x0F)==0x0)))
        { 
         
          for(i=0;i<64;i++)
            {
              buffer[i]=((*datapointer) << 8) | *(datapointer+1);
              datapointer=datapointer+2;
            }
          
          if(tmp2==0xAC11){          //main card
            fillphys(0,&buffer[0]);
            err |= 0xF0;
          }
          else{                      //extra card
            fillphys(1,&buffer[0]);
            err |= 0x0F;
          } 
          tmp1=tmp2=0x0000;
          found++;
        }
      else{
        datapointer++;
        iter=iter+1;}
    }

  return err;

}


unsigned char ACcalib(int length, unsigned char* datapointer, struct calibstruct* calibpointer)
{

  int iter=2;
            
  //point struct-pointer to calibdata
  calibpointer[0]=calibdata[0];  //card1
  calibpointer[1]=calibdata[1];  //card2

  //look for the top header 0xACCA, then the subheaders 0xAC11 and 0xAC22, and unpack the data
  //to each card depending on these.
  while(found<2 && iter<length)
    {
      tmp1 = ((*datapointer) << 8) | *(datapointer+1);
      tmp2 = ((*(datapointer+2)) << 8) | *(datapointer+3);

      if(tmp1 == 0xACCA && ((tmp2 == 0xAC11 && (err&0xF0)==0x0) || (tmp2 == 0xAC22 && (err&0x0F)==0x0)))
        {
          for(i=0;i<8256;i++)
            {
              buffer[i]=((*datapointer) << 8) | *(datapointer+1);
              datapointer=datapointer+2;
            }
         
          if(tmp2==0xAC11){          //main
            fillcalib(0,&buffer[0]);
            err |= 0xF0;
          }
          else{                      //extra
            fillcalib(1,&buffer[0]);
            err |= 0x0F; 
          }
           tmp1=tmp2=0x0000;
          found++;
        }
      else{
        datapointer++;
        iter=iter+1;}
    }

  return err;
}

//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];

}

//Fill calibdata from buffer
void fillcalib(int k,unsigned short *buff)
{
  calibdata[k].header=buff[0];
  for(i=0;i<5;i++) calibdata[k].status[i]=buff[1+i];
  for(i=0;i<8;i++) calibdata[k].temp[i]=buff[6+i];
  for(i=0;i<8;i++) calibdata[k].DAC1[i]=buff[14+i];
  for(i=0;i<8;i++) calibdata[k].DAC2[i]=buff[22+i];
  for(i=0;i<6;i++) calibdata[k].regist[i]=buff[30+i];
  for(i=0;i<8;i++) calibdata[k].time[i]=buff[36+i];
  calibdata[k].n_tr=buff[44];
  for(i=0;i<16;i++) calibdata[k].hitmap_tr[i]=buff[45+i];
  for(i=0;i<4096;i++) calibdata[k].curve1[i]=buff[61+i];
  for(i=0;i<4096;i++) calibdata[k].curve2[i]=buff[4157+i];
  calibdata[k].iCRC=buff[8253];
  calibdata[k].tail=buff[8254];
  calibdata[k].CRC=buff[8255];
}
1	kusanagi	2.2	/*****************************v1.0******************************
2
3			Functions to read AC physics data (ACphysics) and AC calibration
4			data (ACcalib).
5	kusanagi	2.1	Author: Petter Hofverberg, petter@particle.kth.se
6
7	kusanagi	2.2	0410 v1.0 alive
8
9	kusanagi	2.1	Errors: (returned to the main program as the variable "err")
10			err=
11	kusanagi	2.2	0xFF - data (physics or calibration) from both cards found
12			0xF0 - only data from main card found
13			0x0F - only data from extra card found
14			0x00 - no data found
15	kusanagi	2.1
16			******************************************************************/
17
18			#include <stdio.h>
19			#include "AC.h"
20
21	kusanagi	2.2	int i,found,j;
22	kusanagi	2.1	unsigned short buffer[1000];
23	kusanagi	2.2	unsigned short tmp1,tmp2;
24			unsigned char err;
25	kusanagi	2.1
26	kusanagi	2.2	struct physicsstruct physicsdata[2];
27	kusanagi	2.1	struct physicsstruct *physicspointer;
28
29	kusanagi	2.2	struct calibstruct calibdata[2];
30	kusanagi	2.1	struct calibstruct *calibpointer;
31
32
33	kusanagi	2.2
34			unsigned char ACphysics(int length,unsigned char* datapointer,struct physicsstruct* physicspointer)
35	kusanagi	2.1	{
36
37			int iter=2;
38	kusanagi	2.2	physicspointer[0]=physicsdata[0];
39			physicspointer[1]=physicsdata[1];
40	kusanagi	2.1
41	kusanagi	2.2	//look for top header ACAC, then unpack data to main card buffer or extra card buffer depending on the subheader
42			//AC11 for main, AC22 for extra
43			while(found<2 && iter<length)
44	kusanagi	2.1	{
45			tmp1 = ((datapointer) << 8) \| (datapointer+1);
46	kusanagi	2.2	tmp2 = (((datapointer+2)) << 8) \| (datapointer+3);
47
48			if(tmp1 == 0xAC11 && ((tmp2 == 0xAC11 && (err&0xF0)==0x0) \|\| (tmp2 == 0xAC22 && (err&0x0F)==0x0)))
49	kusanagi	2.1	{
50	kusanagi	2.2
51	kusanagi	2.1	for(i=0;i<64;i++)
52			{
53			buffer[i]=((datapointer) << 8) \| (datapointer+1);
54			datapointer=datapointer+2;
55			}
56	kusanagi	2.2
57			if(tmp2==0xAC11){ //main card
58			fillphys(0,&buffer[0]);
59			err \|= 0xF0;
60			}
61			else{ //extra card
62			fillphys(1,&buffer[0]);
63			err \|= 0x0F;
64			}
65			tmp1=tmp2=0x0000;
66			found++;
67	kusanagi	2.1	}
68			else{
69			datapointer++;
70			iter=iter+1;}
71			}
72
73			return err;
74
75			}
76
77
78	kusanagi	2.2	unsigned char ACcalib(int length, unsigned char* datapointer, struct calibstruct* calibpointer)
79	kusanagi	2.1	{
80
81			int iter=2;
82
83			//point struct-pointer to calibdata
84	kusanagi	2.2	calibpointer[0]=calibdata[0]; //card1
85			calibpointer[1]=calibdata[1]; //card2
86	kusanagi	2.1
87	kusanagi	2.2	//look for the top header 0xACCA, then the subheaders 0xAC11 and 0xAC22, and unpack the data
88			//to each card depending on these.
89			while(found<2 && iter<length)
90	kusanagi	2.1	{
91			tmp1 = ((datapointer) << 8) \| (datapointer+1);
92	kusanagi	2.2	tmp2 = (((datapointer+2)) << 8) \| (datapointer+3);
93
94			if(tmp1 == 0xACCA && ((tmp2 == 0xAC11 && (err&0xF0)==0x0) \|\| (tmp2 == 0xAC22 && (err&0x0F)==0x0)))
95	kusanagi	2.1	{
96			for(i=0;i<8256;i++)
97			{
98			buffer[i]=((datapointer) << 8) \| (datapointer+1);
99			datapointer=datapointer+2;
100			}
101	kusanagi	2.2
102			if(tmp2==0xAC11){ //main
103			fillcalib(0,&buffer[0]);
104			err \|= 0xF0;
105			}
106			else{ //extra
107			fillcalib(1,&buffer[0]);
108			err \|= 0x0F;
109			}
110			tmp1=tmp2=0x0000;
111			found++;
112	kusanagi	2.1	}
113			else{
114	kusanagi	2.2	datapointer++;
115			iter=iter+1;}
116	kusanagi	2.1	}
117
118			return err;
119			}
120
121	kusanagi	2.2	//Fill physicsdata from buffer
122			void fillphys(int k,unsigned short *buff)
123			{
124			for(i=0;i<2;i++) physicsdata[k].header[i]=buff[i];
125			physicsdata[k].status=buff[2];
126			physicsdata[k].hitmap=buff[3];
127			for(i=0;i<6;i++) physicsdata[k].regist[i]=buff[4+i];
128			for(i=0;i<16;i++) physicsdata[k].shift[i]=buff[10+i];
129			for(i=0;i<16;i++) physicsdata[k].counters[i]=buff[26+i];
130			for(i=0;i<8;i++) physicsdata[k].coinc[i]=buff[42+i];
131			physicsdata[k].trigg=buff[50];
132			for(i=0;i<2;i++) physicsdata[k].clock[i]=buff[51+i];
133			for(i=0;i<2;i++) physicsdata[k].temp[i]=buff[53+i];
134			for(i=0;i<8;i++) physicsdata[k].DAC[i]=buff[55+i];
135			physicsdata[k].CRC=buff[63];
136	kusanagi	2.1
137	kusanagi	2.2	}
138	kusanagi	2.1
139	kusanagi	2.2	//Fill calibdata from buffer
140			void fillcalib(int k,unsigned short *buff)
141	kusanagi	2.1	{
142	kusanagi	2.2	calibdata[k].header=buff[0];
143			for(i=0;i<5;i++) calibdata[k].status[i]=buff[1+i];
144			for(i=0;i<8;i++) calibdata[k].temp[i]=buff[6+i];
145			for(i=0;i<8;i++) calibdata[k].DAC1[i]=buff[14+i];
146			for(i=0;i<8;i++) calibdata[k].DAC2[i]=buff[22+i];
147			for(i=0;i<6;i++) calibdata[k].regist[i]=buff[30+i];
148			for(i=0;i<8;i++) calibdata[k].time[i]=buff[36+i];
149			calibdata[k].n_tr=buff[44];
150			for(i=0;i<16;i++) calibdata[k].hitmap_tr[i]=buff[45+i];
151			for(i=0;i<4096;i++) calibdata[k].curve1[i]=buff[61+i];
152			for(i=0;i<4096;i++) calibdata[k].curve2[i]=buff[4157+i];
153			calibdata[k].iCRC=buff[8253];
154			calibdata[k].tail=buff[8254];
155			calibdata[k].CRC=buff[8255];
156	kusanagi	2.1	}