chewbacca/PamOffLineSW/PacketSemanticAnalyzer.cpp

//============================================================================
// $Id: PacketSemanticAnalyzer.cpp,v 1.5 2009/07/30 08:16:20 mocchiut Exp $ 
// Description : 
//============================================================================
#include "PacketSemanticAnalyzer.h"

namespace PamOffLineSW
{

extern unsigned long int step_pkt_number;
extern  unsigned long int step_pkt_obt; 
extern  unsigned long int  max_pkt_number; 
extern  unsigned long int  max_pkt_obt; 
extern bool is_new_route;
extern bool do_cont_check;

extern LogUtil* mainLogUtil;
extern long int iNumCadres; //cadre's number  
extern unsigned long long int iByte_tot;// how many bytes I have read till now  

PacketSemanticAnalyzer PacketSemanticAnalyzer::instance;

PacketSemanticAnalyzer::PacketSemanticAnalyzer()
{
        //set current values and last values to zero
        setCurrentValues(0,0);
        setLastValue();
        pkt_type=0;
        pktType=NULL;                           
}                 

PacketSemanticAnalyzer::~PacketSemanticAnalyzer()
{
}

//unused, the values are set in PamOffLineSW_Main.cpp
void PacketSemanticAnalyzer::setStepValue(unsigned long int dpn, unsigned long int dpo )
{
        step_pkt_number=dpn;
        step_pkt_obt=dpo;
}

void PacketSemanticAnalyzer::setLastValue()
{
        last_pkt_number=pkt_number;
        last_pkt_obt=pkt_obt;   
}

void PacketSemanticAnalyzer::setCurrentValues(unsigned long int ex_pkt_number, unsigned long int ex_pkt_obt)
{
        pkt_number=ex_pkt_number;
        pkt_obt=ex_pkt_obt;
}


void PacketSemanticAnalyzer::extractValuesfromPKT(char * hpamPkt)
{
        
/**/
        //all the check can also be done using  pamela::techmodel::EventReader* reader; 
        //PacketUser::getInstance().reader->PKT_UnpackPscuHeader(hpamPkt);              
        //std::cout<<PacketUser::getInstance().reader->Header->GetPscuHeader()->Print()<<std::endl;
  //reader->Header->GetCounter()->PrintCounters();
        //const PacketType* type =      reader->Header->GetPscuHeader()->GetPacketType();
        //int len= reader->Header->GetPscuHeader()->GetPacketLenght();
        //if(reader){delete reader; reader = NULL;}
         
/**/    
        unsigned long  int ex_pkt_number=(unsigned long int)(unsigned char)(hpamPkt[7])+
                                              256*(unsigned long int)(unsigned char)(hpamPkt[6])+
                                          256*256*(unsigned long int)(unsigned char)(hpamPkt[5]);
        //unsigned int  Counter   = (((UINT32)buff[5]<<16)&0x00FF0000) + (((UINT32)buff[6]<<8)&0x0000FF00) + (((UINT32)buff[7])&0x000000FF);
                       
        unsigned long  int ex_pkt_obt=(unsigned long int)(unsigned char)(hpamPkt[11])+
                              256*(unsigned long int)(unsigned char)(hpamPkt[10])+
                           256*256*(unsigned long int)(unsigned char)(hpamPkt[9])+
                       256*256*256*(unsigned long int)(unsigned char)(hpamPkt[8]);
        
        //unsigned int  OrbitalTime  = (((UINT32)buff[8]<<24)&0xFF000000) + (((UINT32)buff[9]<<16)&0x00FF0000) +  (((UINT32)buff[10]<<8)&0x0000FF00) + (((UINT32)buff[11])&0x000000FF);

        setCurrentValues(ex_pkt_number,ex_pkt_obt);
        
        //if hpamPkt[3] != hpamPkt[4]  the pkt is not good, it was discarded in R3
        pkt_type=(unsigned char)(hpamPkt[3]);
        pktType = GetPacketType(pkt_type);      
}

// PacketSemanticAnalyzer: 
// return false if there is a DISCONTINUITY
// packet counter has priority on obt.
bool PacketSemanticAnalyzer::analysePKT()
{
        
        if(!pktType){
                stringstream oss;
                oss.str()="";
                oss<<"PacketType "<<(int)pkt_type <<" not recognised. Packed skipped. The end of this packet is at byte: "<<iByte_tot<<" in cadre "<<iNumCadres;
                string msg = oss.str();
                mainLogUtil->logError(msg);
                // the packet will not be used in the next module.
                //I don't call setLastValue(), I can't trust on this packet                     
                return true;
        }
        
        //IF I FOUND A NEW DOWNLOAD IN THE INPUT FILE, discontinuity
        if(is_new_route){
                setLastValue(); 
                return false;           
        }

        if(!do_cont_check){
                setLastValue();//maybe I don't need it  
                return true;
        }
        
        long int delta_pc;              
        long int delta_pt;
        bool cons=true;
        
        //TODO check here ... 
        //USE ONLY PKT_NUMBER and not the OBT ... 
        //correct value is step_pkt_number = 5 and step_pkt_obt =0
        delta_pc = pkt_number-last_pkt_number;  

        if((step_pkt_number==0)||
           ((delta_pc>0)&&(delta_pc<=(long long int)step_pkt_number)) ||
           ((delta_pc<0)&&(-delta_pc>=(long long int)(max_pkt_number-step_pkt_number)))//delta_pc < 0 et pkt_number small and last_pkt_number big
        )                       
        {
                //cons=true;
                delta_pt=pkt_obt-last_pkt_obt;          
        
                //delta_pt=0 is OK
                if((step_pkt_obt==0)||
                   ((delta_pt>=0)&&(delta_pt<=(long long int)step_pkt_obt)) ||
                   ((delta_pt<0)&&(-delta_pt>=(long long int)(max_pkt_obt-step_pkt_obt)))//delta_pt < 0 et pkt_obt small and last_pkt_obt big
                )
                {
                        cons=true;
                }
                else
                {
                        cons=false;
                }       
        }
        else
        {
                cons=false;
        }
        
        setLastValue(); 
        return cons;
}

//here headerPkt is the header (16 bytes) pamPKT is the rest of the packet of lenght = length
void PacketSemanticAnalyzer::managePKT(char*& headerPkt, char*& pamPkt, long int length,  bool isPKTGood)
{               
        bool isCons = true;     
        //here we retrieve the informations mostly from the header
        extractValuesfromPKT(headerPkt);        
        //here I use the information retrieved to decide if the current packet is continuos 
        isCons=analysePKT();
                
        //The quality of the packet isPKTGood and the information about "CONTINUITY" 
        //are sent to the "user module" where I will save/use it.
        PacketUser::getInstance().usePKT(headerPkt, pamPkt, length, isCons, isPKTGood,
                        pktType, pkt_number, pkt_obt);
        
        //just to be sure ...
        if(pamPkt){ delete[] pamPkt; pamPkt = NULL;}
        if(headerPkt){ delete[] headerPkt; headerPkt = NULL;}           
}

/**
 * Get the packet type, this function is analogous to the one in  ../event/PacketType.h
 */
const PacketType* PacketSemanticAnalyzer::GetPacketType(unsigned char pkt_type)  {
switch (pkt_type) {
    case 0x07: return PacketType::PhysEndRun;//warning nel computo CRC
    case 0x08: return PacketType::CalibCalPulse1;
    case 0x09: return PacketType::CalibCalPulse2;
        case 0x10: return PacketType::Physics;
    case 0x11: return PacketType::CalibTrkBoth;
    case 0x12: return PacketType::CalibTrk1;
    case 0x13: return PacketType::CalibTrk2;
    case 0x16: return PacketType::CalibTof;
    case 0x17: return PacketType::CalibS4;
    case 0x18: return PacketType::CalibCalPed;
    case 0x19: return PacketType::Calib1_Ac1;
    case 0x1A: return PacketType::Calib2_Ac1;
    case 0x1B: return PacketType::Calib1_Ac2;
    case 0x1C: return PacketType::Calib2_Ac2;
    case 0x1D: return PacketType::CalibCal;
    case 0x20: return PacketType::RunHeader;
    case 0x21: return PacketType::RunTrailer; 
    case 0x22: return PacketType::CalibHeader;
    case 0x23: return PacketType::CalibTrailer;
    case 0x24: return PacketType::InitHeader;
    case 0x25: return PacketType::InitTrailer;
    case 0x30: return PacketType::EventTrk;
    case 0x50: return PacketType::Log;
    case 0x51: return PacketType::VarDump;
    case 0x52: return PacketType::ArrDump;
    case 0x53: return PacketType::TabDump;
    case 0x54: return PacketType::Tmtc;
    case 0x55: return PacketType::Mcmd;
    case 0x60: return PacketType::ForcedFECmd;
    case 0x70: return PacketType::Ac1Init;
    case 0x71: return PacketType::CalInit;
    case 0x72: return PacketType::TrkInit;
    case 0x73: return PacketType::TofInit;
    case 0x74: return PacketType::TrgInit;
    case 0x75: return PacketType::NdInit;
    case 0x76: return PacketType::S4Init;
    case 0x77: return PacketType::Ac2Init;
    case 0x81: return PacketType::CalAlarm;
    case 0x82: return PacketType::Ac1Alarm;
    case 0x83: return PacketType::TrkAlarm;
    case 0x84: return PacketType::TrgAlarm;
    case 0x85: return PacketType::TofAlarm;
    case 0x86: return PacketType::S4Alarm;
    case 0x89: return PacketType::Ac2Alarm;
    case 0xA1: return PacketType::TsbT; 
    case 0xAB: return PacketType::TsbB; 
        default: {
           return NULL;
          }
  }

}


PacketSemanticAnalyzer& PacketSemanticAnalyzer::getInstance()
{
        return instance;
}


}

1	//============================================================================
2	// $Id: PacketSemanticAnalyzer.cpp,v 1.5 2009/07/30 08:16:20 mocchiut Exp $
3	// Description :
4	//============================================================================
5	#include "PacketSemanticAnalyzer.h"
6
7	namespace PamOffLineSW
8	{
9
10	extern unsigned long int step_pkt_number;
11	extern unsigned long int step_pkt_obt;
12	extern unsigned long int max_pkt_number;
13	extern unsigned long int max_pkt_obt;
14	extern bool is_new_route;
15	extern bool do_cont_check;
16
17	extern LogUtil* mainLogUtil;
18	extern long int iNumCadres; //cadre's number
19	extern unsigned long long int iByte_tot;// how many bytes I have read till now
20
21	PacketSemanticAnalyzer PacketSemanticAnalyzer::instance;
22
23	PacketSemanticAnalyzer::PacketSemanticAnalyzer()
24	{
25	//set current values and last values to zero
26	setCurrentValues(0,0);
27	setLastValue();
28	pkt_type=0;
29	pktType=NULL;
30	}
31
32	PacketSemanticAnalyzer::~PacketSemanticAnalyzer()
33	{
34	}
35
36	//unused, the values are set in PamOffLineSW_Main.cpp
37	void PacketSemanticAnalyzer::setStepValue(unsigned long int dpn, unsigned long int dpo )
38	{
39	step_pkt_number=dpn;
40	step_pkt_obt=dpo;
41	}
42
43	void PacketSemanticAnalyzer::setLastValue()
44	{
45	last_pkt_number=pkt_number;
46	last_pkt_obt=pkt_obt;
47	}
48
49	void PacketSemanticAnalyzer::setCurrentValues(unsigned long int ex_pkt_number, unsigned long int ex_pkt_obt)
50	{
51	pkt_number=ex_pkt_number;
52	pkt_obt=ex_pkt_obt;
53	}
54
55
56	void PacketSemanticAnalyzer::extractValuesfromPKT(char * hpamPkt)
57	{
58
59	/**/
60	//all the check can also be done using pamela::techmodel::EventReader* reader;
61	//PacketUser::getInstance().reader->PKT_UnpackPscuHeader(hpamPkt);
62	//std::cout<<PacketUser::getInstance().reader->Header->GetPscuHeader()->Print()<<std::endl;
63	//reader->Header->GetCounter()->PrintCounters();
64	//const PacketType* type = reader->Header->GetPscuHeader()->GetPacketType();
65	//int len= reader->Header->GetPscuHeader()->GetPacketLenght();
66	//if(reader){delete reader; reader = NULL;}
67
68	/**/
69	unsigned long int ex_pkt_number=(unsigned long int)(unsigned char)(hpamPkt[7])+
70	256*(unsigned long int)(unsigned char)(hpamPkt[6])+
71	256256(unsigned long int)(unsigned char)(hpamPkt[5]);
72	//unsigned int Counter = (((UINT32)buff[5]<<16)&0x00FF0000) + (((UINT32)buff[6]<<8)&0x0000FF00) + (((UINT32)buff[7])&0x000000FF);
73
74	unsigned long int ex_pkt_obt=(unsigned long int)(unsigned char)(hpamPkt[11])+
75	256*(unsigned long int)(unsigned char)(hpamPkt[10])+
76	256256(unsigned long int)(unsigned char)(hpamPkt[9])+
77	256256256*(unsigned long int)(unsigned char)(hpamPkt[8]);
78
79	//unsigned int OrbitalTime = (((UINT32)buff[8]<<24)&0xFF000000) + (((UINT32)buff[9]<<16)&0x00FF0000) + (((UINT32)buff[10]<<8)&0x0000FF00) + (((UINT32)buff[11])&0x000000FF);
80
81	setCurrentValues(ex_pkt_number,ex_pkt_obt);
82
83	//if hpamPkt[3] != hpamPkt[4] the pkt is not good, it was discarded in R3
84	pkt_type=(unsigned char)(hpamPkt[3]);
85	pktType = GetPacketType(pkt_type);
86	}
87
88	// PacketSemanticAnalyzer:
89	// return false if there is a DISCONTINUITY
90	// packet counter has priority on obt.
91	bool PacketSemanticAnalyzer::analysePKT()
92	{
93
94	if(!pktType){
95	stringstream oss;
96	oss.str()="";
97	oss<<"PacketType "<<(int)pkt_type <<" not recognised. Packed skipped. The end of this packet is at byte: "<<iByte_tot<<" in cadre "<<iNumCadres;
98	string msg = oss.str();
99	mainLogUtil->logError(msg);
100	// the packet will not be used in the next module.
101	//I don't call setLastValue(), I can't trust on this packet
102	return true;
103	}
104
105	//IF I FOUND A NEW DOWNLOAD IN THE INPUT FILE, discontinuity
106	if(is_new_route){
107	setLastValue();
108	return false;
109	}
110
111	if(!do_cont_check){
112	setLastValue();//maybe I don't need it
113	return true;
114	}
115
116	long int delta_pc;
117	long int delta_pt;
118	bool cons=true;
119
120	//TODO check here ...
121	//USE ONLY PKT_NUMBER and not the OBT ...
122	//correct value is step_pkt_number = 5 and step_pkt_obt =0
123	delta_pc = pkt_number-last_pkt_number;
124
125	if((step_pkt_number==0)\|\|
126	((delta_pc>0)&&(delta_pc<=(long long int)step_pkt_number)) \|\|
127	((delta_pc<0)&&(-delta_pc>=(long long int)(max_pkt_number-step_pkt_number)))//delta_pc < 0 et pkt_number small and last_pkt_number big
128	)
129	{
130	//cons=true;
131	delta_pt=pkt_obt-last_pkt_obt;
132
133	//delta_pt=0 is OK
134	if((step_pkt_obt==0)\|\|
135	((delta_pt>=0)&&(delta_pt<=(long long int)step_pkt_obt)) \|\|
136	((delta_pt<0)&&(-delta_pt>=(long long int)(max_pkt_obt-step_pkt_obt)))//delta_pt < 0 et pkt_obt small and last_pkt_obt big
137	)
138	{
139	cons=true;
140	}
141	else
142	{
143	cons=false;
144	}
145	}
146	else
147	{
148	cons=false;
149	}
150
151	setLastValue();
152	return cons;
153	}
154
155	//here headerPkt is the header (16 bytes) pamPKT is the rest of the packet of lenght = length
156	void PacketSemanticAnalyzer::managePKT(char& headerPkt, char& pamPkt, long int length, bool isPKTGood)
157	{
158	bool isCons = true;
159	//here we retrieve the informations mostly from the header
160	extractValuesfromPKT(headerPkt);
161	//here I use the information retrieved to decide if the current packet is continuos
162	isCons=analysePKT();
163
164	//The quality of the packet isPKTGood and the information about "CONTINUITY"
165	//are sent to the "user module" where I will save/use it.
166	PacketUser::getInstance().usePKT(headerPkt, pamPkt, length, isCons, isPKTGood,
167	pktType, pkt_number, pkt_obt);
168
169	//just to be sure ...
170	if(pamPkt){ delete[] pamPkt; pamPkt = NULL;}
171	if(headerPkt){ delete[] headerPkt; headerPkt = NULL;}
172	}
173
174	/**
175	* Get the packet type, this function is analogous to the one in ../event/PacketType.h
176	*/
177	const PacketType* PacketSemanticAnalyzer::GetPacketType(unsigned char pkt_type) {
178	switch (pkt_type) {
179	case 0x07: return PacketType::PhysEndRun;//warning nel computo CRC
180	case 0x08: return PacketType::CalibCalPulse1;
181	case 0x09: return PacketType::CalibCalPulse2;
182	case 0x10: return PacketType::Physics;
183	case 0x11: return PacketType::CalibTrkBoth;
184	case 0x12: return PacketType::CalibTrk1;
185	case 0x13: return PacketType::CalibTrk2;
186	case 0x16: return PacketType::CalibTof;
187	case 0x17: return PacketType::CalibS4;
188	case 0x18: return PacketType::CalibCalPed;
189	case 0x19: return PacketType::Calib1_Ac1;
190	case 0x1A: return PacketType::Calib2_Ac1;
191	case 0x1B: return PacketType::Calib1_Ac2;
192	case 0x1C: return PacketType::Calib2_Ac2;
193	case 0x1D: return PacketType::CalibCal;
194	case 0x20: return PacketType::RunHeader;
195	case 0x21: return PacketType::RunTrailer;
196	case 0x22: return PacketType::CalibHeader;
197	case 0x23: return PacketType::CalibTrailer;
198	case 0x24: return PacketType::InitHeader;
199	case 0x25: return PacketType::InitTrailer;
200	case 0x30: return PacketType::EventTrk;
201	case 0x50: return PacketType::Log;
202	case 0x51: return PacketType::VarDump;
203	case 0x52: return PacketType::ArrDump;
204	case 0x53: return PacketType::TabDump;
205	case 0x54: return PacketType::Tmtc;
206	case 0x55: return PacketType::Mcmd;
207	case 0x60: return PacketType::ForcedFECmd;
208	case 0x70: return PacketType::Ac1Init;
209	case 0x71: return PacketType::CalInit;
210	case 0x72: return PacketType::TrkInit;
211	case 0x73: return PacketType::TofInit;
212	case 0x74: return PacketType::TrgInit;
213	case 0x75: return PacketType::NdInit;
214	case 0x76: return PacketType::S4Init;
215	case 0x77: return PacketType::Ac2Init;
216	case 0x81: return PacketType::CalAlarm;
217	case 0x82: return PacketType::Ac1Alarm;
218	case 0x83: return PacketType::TrkAlarm;
219	case 0x84: return PacketType::TrgAlarm;
220	case 0x85: return PacketType::TofAlarm;
221	case 0x86: return PacketType::S4Alarm;
222	case 0x89: return PacketType::Ac2Alarm;
223	case 0xA1: return PacketType::TsbT;
224	case 0xAB: return PacketType::TsbB;
225	default: {
226	return NULL;
227	}
228	}
229
230	}
231
232
233	PacketSemanticAnalyzer& PacketSemanticAnalyzer::getInstance()
234	{
235	return instance;
236	}
237
238
239	}
240