yoda/event/CRC.h

/****************************************************************************
 *  F i l e   D a t a                                                        
 *  $Id: CRC.h,v 4.4 2005/05/28 10:44:08 kusanagi Exp $
 *  $Revision: 4.4 $ 
 *  $Date: 2005/05/28 10:44:08 $     
 *  $RCSfile: CRC.h,v $ 
 *                                                                           
 ****************************************************************************
 *  S W   D e v e l o p m e n t   E n v i r o n m e n t                      
 *                                                                           
 *  $Author: kusanagi $                                                                   
 *               :                                                           
 *****************************************************************************/

#ifndef CRC_H
#define CRC_H

#define BYTE       unsigned char 
#define  UINT32 unsigned int 
#define  UINT16 unsigned short 


/**   Example of CAST macro at work. public domain demo by Bob Stout.
 *
 *       Example of CAST macro at work                                   
 *                                                                       
 *       union {                                                         
 *               char    ch[4];                                         
 *               int     i[2];                                           
 *       } my_union;                                                    
 *                                                                      
 *       long    longvar;                                                
 *                                                                       
 *               longvar = (long)my_union;        Illegal cast           
 *               longvar = CAST(long, my_union);  Legal cast             
 *                                                                       
 */
#define CM_CAST(new_type,old_object) (*((new_type *)&(old_object)))


#define CM_HI_UINT16(x) ( (BYTE)( ((x) & 0xff00)>>8 ) )
#define CM_LO_UINT16(x) ( (BYTE)( ((x) & 0x00ff) ) )

#define CM_HI_UINT32(x) ( (UINT16)( ((x) & 0xffff0000)>>16 ) )
#define CM_LO_UINT32(x) ( (UINT16)( ((x) & 0x0000ffff) ) )


#define CM_HIHI_UINT32(x) ( (BYTE)( ((x) & 0xff000000)>>24 ) )
#define CM_LOHI_UINT32(x) ( (BYTE)( ((x) & 0x00ff0000)>>16 ) )
#define CM_HILO_UINT32(x) ( (BYTE)( ((x) & 0x0000ff00)>> 8 ) )
#define CM_LOLO_UINT32(x) ( (BYTE)( ((x) & 0x000000ff)     ) )


/**
   Macro READ_NEXT_BITS_UINT(wordlen,p,offset,n,res)

   this mascro scans bits for a 'wordlen'-bit long word. 'wordlen' can be 8,16,32...
   It reads the next 'n' bits starting after the 'offset'-th bit of the 'wordlen'-bit word pointed by p.
   store the result in 'res', and increment properly both 'offset' and 'p' such that they can be reused
   in the text invocation of the macro.

     \a p        unsigned 'wordlen'-bit pointer (ie. wordlen==16, then unsinged short int * in i386 arch) 
              varibale name.
              it points to the word to scan. it is incremented automatically by the macro.
     \a offset   unsigned  8 bit variable name (unsigned char?). Must be an l-value.
              it holds the number of bit already read in the most significant part of the
              current pointer (*p). Should be used always the same variable while a scanning
              session. This value must be initialized to zero and should be always less then 'wordlen'.
     \a n        the number of bits to read. Can be a r-value. Must be   0 <= n <= 'wordlen'. 
              if n is zero (senseless), both 'p' and 'offset' are unchanged and 0 is returned in 'res'.
     \a res      unsigned 'wordlen'-bit variable name (i.e wordlen==16, then unsigned short int? on i386 arch)
              in which to store the requested 'n' bits.
              they are returned in the less significat part of 'res'. If n<'wordlen', then the most
              significant bits of 'res' are padded to zero.
   
   before using he macro the first time you have to: (let's assume 'wordlen' fixed to 16 and an i386 arch.)
     1) choose an unsigned short pointer to pass as 'p', and initialize it to the sequence 
        of bits to scan from.
     2) choose an unsigned  char variable to pass as 'offset' and initialize it to zero 
        (or some other value X<16, if you want to skip the first X bits)
     3) choose an unsigned short to return the result.
     
*/

#define CM_READ_NEXT_BITS_UINT(wordlen,p,offset,n,res) \
do {                                     \
    res = (*p << offset);                \
    res >>= (wordlen-(n));               \
    if(n<=wordlen-offset) {              \
      offset=(offset+(n))%wordlen;       \
      if(offset==0)                      \
         p++;                            \
    }else{                               \
      p++;                               \
      res |= *p>>(wordlen*2-offset-(n)); \
      offset+=(n)-wordlen;               \
    }                                    \
}while(0)

/* Wrapper to 8,16,32,64 bit link wrapper to READ_NEXT_BITS_UINT : */
#define CM_READ_NEXT_BITS_UINT8(p,offset,n,res)  CM_READ_NEXT_BITS_UINT(8 ,p,offset,n,res)
#define CM_READ_NEXT_BITS_UINT16(p,offset,n,res) CM_READ_NEXT_BITS_UINT(16,p,offset,n,res)
#define CM_READ_NEXT_BITS_UINT32(p,offset,n,res) CM_READ_NEXT_BITS_UINT(32,p,offset,n,res)
#define CM_READ_NEXT_BITS_UINT64(p,offset,n,res) CM_READ_NEXT_BITS_UINT(64,p,offset,n,res)

#define CM_GET_BIT(exp,n) (((exp) >> ((n)-1)) & 0x1)


/* Thees macros write a 16 or 32 bits in BigEndian fascion in a (unsigned char*) avoiding the
   addressing alignement problem and also increment ptr
     - ptr    must be a (unsigned char*) pointer (l-value)
     - byte   must be a (unsigned char)          (r-value)
     - word   must be a (unsigned short int)     (r-value)
     - dword  must be a (unsigned int)           (r-value)
 */
#define CM_WRITE_BE_UINT8(ptr,byte) do { *ptr = (unsigned char)(byte); ptr++;} while(0)

#define CM_WRITE_BE_UINT16(ptr,word) do { \
  CM_WRITE_BE_UINT8(ptr,((word)>>8)); \
  CM_WRITE_BE_UINT8(ptr,(word)); \
} while(0)

#define CM_WRITE_BE_UINT32(ptr,dword) do { \
  CM_WRITE_BE_UINT8(ptr,(dword)>>24); \
  CM_WRITE_BE_UINT8(ptr,(dword)>>16); \
  CM_WRITE_BE_UINT8(ptr,(dword)>>8); \
  CM_WRITE_BE_UINT8(ptr,(dword));      \
} while(0)

/* Thees macros read a 16 or 32 bits in BigEndian fascion from a (unsigned char*) avoiding the
   addressing alignement problem and also increment ptr
     - ptr    must be a (unsigned char*) pointer (l-value)
     - byte and temp   must be a (unsigned char)          (l-value)
     - word   must be a (unsigned short int)     (l-value)
     - dword  must be a (unsigned int)           (l-value)
 */
#define CM_READ_BE_UINT8(ptr,byte) do { byte = *(ptr); (ptr)++; } while(0)

#define CM_READ_BE_UINT16(ptr,word,temp) do { \
  CM_READ_BE_UINT8(ptr,temp);             \
  word = ((unsigned short int)temp) << 8; \
  CM_READ_BE_UINT8(ptr,temp);             \
  word |= temp;                            \
} while(0)

#define CM_READ_BE_UINT32(ptr,word,temp) do { \
  CM_READ_BE_UINT8(ptr,temp);         \
  word =  ((unsigned int)temp) << 24;  \
  CM_READ_BE_UINT8(ptr,temp);         \
  word |= ((unsigned int)temp) << 16;  \
  CM_READ_BE_UINT8(ptr,temp);         \
  word |= ((unsigned int)temp) <<  8;  \
  CM_READ_BE_UINT8(ptr,temp);         \
  word |= ((unsigned int)temp);        \
} while(0)


/** Univeral BIT converter to 2 registers set with different resolution.
    Used in Microsecond to register converte for data time out and event time
    out and other same-style register.
    
    \a v        is the value in some unit
    \a unit_h   is the resolution of the MSD-part. must be in same unit of v.
    \a no_bit_h is the number of bits of the MSD-part.
    \a unit_l   is the resolution of the LSD-part. must be in same unit of v.
    \a no_bit_l is the number of bits of the LSD-part.
    
    \example (case of ETO)
    Suppose to have 2 8-bit registers ETO1 (8 bit,LSB) and ETO2 (8 bit,HSB): 
    ETO2 have a resoluion of 65 microsec;
    ETOHSB have a resolution of 16 millisec;

    This will format a value of 1 millisecond (unit is in microsecond)
    the usage is: CM_TIME2REG(1000,16*1000,8,65,8)

 */

//#define CM_TIME2REG(v,unit_h,no_bit_h,unit_l,no_bit_l) ((((v)/(unit_h))<<(no_bit_l) ) | ((((v)%(unit_h))/(unit_l)) & ~((0xffffffff)<<((no_bit_l)+(no_bit_h)))))

//#define CM_INT_UNUSED 0


/**
   Compute a 8 bit CRC based on a \a data, whith a \a old pre-computed crc.   
 */
/** old   ---> the old pre-computed crc */
/** data ---> the data to compute crc for */
BYTE CM_crc8_8(BYTE old, BYTE data);

UINT32 CM_Compute_CRC8_8(UINT32 oldcrc
                         ,BYTE *buffer 
                         ,UINT32 length 
                         );


UINT16 CM_CRC16(BYTE* adrs, UINT16 Crc);
UINT16 CM_Compute_CRC16(UINT16 oldcrc,BYTE *buffer,UINT32 length);

BYTE* charToUnsignedChar(char buffer[], UINT32 length);

#endif /* CRC_H */


1	kusanagi	1.1	/****************************************************************************
2			* F i l e D a t a
3	kusanagi	5.0	* $Id: CRC.h,v 4.4 2005/05/28 10:44:08 kusanagi Exp $
4			* $Revision: 4.4 $
5			* $Date: 2005/05/28 10:44:08 $
6	kusanagi	1.1	* $RCSfile: CRC.h,v $
7			*
8			****************************************************************************
9			* S W D e v e l o p m e n t E n v i r o n m e n t
10			*
11	kusanagi	2.0	* $Author: kusanagi $
12	kusanagi	1.1	* :
13			*****************************************************************************/
14
15			#ifndef CRC_H
16			#define CRC_H
17
18			#define BYTE unsigned char
19			#define UINT32 unsigned int
20			#define UINT16 unsigned short
21
22
23			/** Example of CAST macro at work. public domain demo by Bob Stout.
24			*
25			* Example of CAST macro at work
26			*
27			* union {
28			* char ch[4];
29			* int i[2];
30			* } my_union;
31			*
32			* long longvar;
33			*
34			* longvar = (long)my_union; Illegal cast
35			* longvar = CAST(long, my_union); Legal cast
36			*
37			*/
38			#define CM_CAST(new_type,old_object) (((new_type )&(old_object)))
39
40
41			#define CM_HI_UINT16(x) ( (BYTE)( ((x) & 0xff00)>>8 ) )
42			#define CM_LO_UINT16(x) ( (BYTE)( ((x) & 0x00ff) ) )
43
44			#define CM_HI_UINT32(x) ( (UINT16)( ((x) & 0xffff0000)>>16 ) )
45			#define CM_LO_UINT32(x) ( (UINT16)( ((x) & 0x0000ffff) ) )
46
47
48			#define CM_HIHI_UINT32(x) ( (BYTE)( ((x) & 0xff000000)>>24 ) )
49			#define CM_LOHI_UINT32(x) ( (BYTE)( ((x) & 0x00ff0000)>>16 ) )
50			#define CM_HILO_UINT32(x) ( (BYTE)( ((x) & 0x0000ff00)>> 8 ) )
51			#define CM_LOLO_UINT32(x) ( (BYTE)( ((x) & 0x000000ff) ) )
52
53
54
55			/**
56			Macro READ_NEXT_BITS_UINT(wordlen,p,offset,n,res)
57
58			this mascro scans bits for a 'wordlen'-bit long word. 'wordlen' can be 8,16,32...
59			It reads the next 'n' bits starting after the 'offset'-th bit of the 'wordlen'-bit word pointed by p.
60			store the result in 'res', and increment properly both 'offset' and 'p' such that they can be reused
61			in the text invocation of the macro.
62
63			\a p unsigned 'wordlen'-bit pointer (ie. wordlen==16, then unsinged short int * in i386 arch)
64			varibale name.
65			it points to the word to scan. it is incremented automatically by the macro.
66			\a offset unsigned 8 bit variable name (unsigned char?). Must be an l-value.
67			it holds the number of bit already read in the most significant part of the
68			current pointer (*p). Should be used always the same variable while a scanning
69			session. This value must be initialized to zero and should be always less then 'wordlen'.
70			\a n the number of bits to read. Can be a r-value. Must be 0 <= n <= 'wordlen'.
71			if n is zero (senseless), both 'p' and 'offset' are unchanged and 0 is returned in 'res'.
72			\a res unsigned 'wordlen'-bit variable name (i.e wordlen==16, then unsigned short int? on i386 arch)
73			in which to store the requested 'n' bits.
74			they are returned in the less significat part of 'res'. If n<'wordlen', then the most
75			significant bits of 'res' are padded to zero.
76
77			before using he macro the first time you have to: (let's assume 'wordlen' fixed to 16 and an i386 arch.)
78			1) choose an unsigned short pointer to pass as 'p', and initialize it to the sequence
79			of bits to scan from.
80			2) choose an unsigned char variable to pass as 'offset' and initialize it to zero
81			(or some other value X<16, if you want to skip the first X bits)
82			3) choose an unsigned short to return the result.
83
84			*/
85
86			#define CM_READ_NEXT_BITS_UINT(wordlen,p,offset,n,res) \
87			do { \
88			res = (*p << offset); \
89			res >>= (wordlen-(n)); \
90			if(n<=wordlen-offset) { \
91			offset=(offset+(n))%wordlen; \
92			if(offset==0) \
93			p++; \
94			}else{ \
95			p++; \
96			res \|= p>>(wordlen2-offset-(n)); \
97			offset+=(n)-wordlen; \
98			} \
99			}while(0)
100
101			/* Wrapper to 8,16,32,64 bit link wrapper to READ_NEXT_BITS_UINT : */
102			#define CM_READ_NEXT_BITS_UINT8(p,offset,n,res) CM_READ_NEXT_BITS_UINT(8 ,p,offset,n,res)
103			#define CM_READ_NEXT_BITS_UINT16(p,offset,n,res) CM_READ_NEXT_BITS_UINT(16,p,offset,n,res)
104			#define CM_READ_NEXT_BITS_UINT32(p,offset,n,res) CM_READ_NEXT_BITS_UINT(32,p,offset,n,res)
105			#define CM_READ_NEXT_BITS_UINT64(p,offset,n,res) CM_READ_NEXT_BITS_UINT(64,p,offset,n,res)
106
107			#define CM_GET_BIT(exp,n) (((exp) >> ((n)-1)) & 0x1)
108
109
110
111
112			/* Thees macros write a 16 or 32 bits in BigEndian fascion in a (unsigned char*) avoiding the
113			addressing alignement problem and also increment ptr
114			- ptr must be a (unsigned char*) pointer (l-value)
115			- byte must be a (unsigned char) (r-value)
116			- word must be a (unsigned short int) (r-value)
117			- dword must be a (unsigned int) (r-value)
118			*/
119			#define CM_WRITE_BE_UINT8(ptr,byte) do { *ptr = (unsigned char)(byte); ptr++;} while(0)
120
121			#define CM_WRITE_BE_UINT16(ptr,word) do { \
122			CM_WRITE_BE_UINT8(ptr,((word)>>8)); \
123			CM_WRITE_BE_UINT8(ptr,(word)); \
124			} while(0)
125
126			#define CM_WRITE_BE_UINT32(ptr,dword) do { \
127			CM_WRITE_BE_UINT8(ptr,(dword)>>24); \
128			CM_WRITE_BE_UINT8(ptr,(dword)>>16); \
129			CM_WRITE_BE_UINT8(ptr,(dword)>>8); \
130			CM_WRITE_BE_UINT8(ptr,(dword)); \
131			} while(0)
132
133			/* Thees macros read a 16 or 32 bits in BigEndian fascion from a (unsigned char*) avoiding the
134			addressing alignement problem and also increment ptr
135			- ptr must be a (unsigned char*) pointer (l-value)
136			- byte and temp must be a (unsigned char) (l-value)
137			- word must be a (unsigned short int) (l-value)
138			- dword must be a (unsigned int) (l-value)
139			*/
140			#define CM_READ_BE_UINT8(ptr,byte) do { byte = *(ptr); (ptr)++; } while(0)
141
142			#define CM_READ_BE_UINT16(ptr,word,temp) do { \
143			CM_READ_BE_UINT8(ptr,temp); \
144			word = ((unsigned short int)temp) << 8; \
145			CM_READ_BE_UINT8(ptr,temp); \
146			word \|= temp; \
147			} while(0)
148
149			#define CM_READ_BE_UINT32(ptr,word,temp) do { \
150			CM_READ_BE_UINT8(ptr,temp); \
151			word = ((unsigned int)temp) << 24; \
152			CM_READ_BE_UINT8(ptr,temp); \
153			word \|= ((unsigned int)temp) << 16; \
154			CM_READ_BE_UINT8(ptr,temp); \
155			word \|= ((unsigned int)temp) << 8; \
156			CM_READ_BE_UINT8(ptr,temp); \
157			word \|= ((unsigned int)temp); \
158			} while(0)
159
160
161			/** Univeral BIT converter to 2 registers set with different resolution.
162			Used in Microsecond to register converte for data time out and event time
163			out and other same-style register.
164
165			\a v is the value in some unit
166			\a unit_h is the resolution of the MSD-part. must be in same unit of v.
167			\a no_bit_h is the number of bits of the MSD-part.
168			\a unit_l is the resolution of the LSD-part. must be in same unit of v.
169			\a no_bit_l is the number of bits of the LSD-part.
170
171			\example (case of ETO)
172			Suppose to have 2 8-bit registers ETO1 (8 bit,LSB) and ETO2 (8 bit,HSB):
173			ETO2 have a resoluion of 65 microsec;
174			ETOHSB have a resolution of 16 millisec;
175
176			This will format a value of 1 millisecond (unit is in microsecond)
177			the usage is: CM_TIME2REG(1000,16*1000,8,65,8)
178
179			*/
180
181			//#define CM_TIME2REG(v,unit_h,no_bit_h,unit_l,no_bit_l) ((((v)/(unit_h))<<(no_bit_l) ) \| ((((v)%(unit_h))/(unit_l)) & ~((0xffffffff)<<((no_bit_l)+(no_bit_h)))))
182
183			//#define CM_INT_UNUSED 0
184
185
186			/**
187			Compute a 8 bit CRC based on a \a data, whith a \a old pre-computed crc.
188			*/
189			/** old ---> the old pre-computed crc */
190			/** data ---> the data to compute crc for */
191			BYTE CM_crc8_8(BYTE old, BYTE data);
192
193			UINT32 CM_Compute_CRC8_8(UINT32 oldcrc
194			,BYTE *buffer
195			,UINT32 length
196			);
197
198
199			UINT16 CM_CRC16(BYTE* adrs, UINT16 Crc);
200			UINT16 CM_Compute_CRC16(UINT16 oldcrc,BYTE *buffer,UINT32 length);
201
202			BYTE* charToUnsignedChar(char buffer[], UINT32 length);
203
204			#endif /* CRC_H */
205
206
207