CRC CRC-16-CCITT - before i go bald !!

Hi All,

Before I go BALD from tearing my hair out I remembered my Experts Exchange account, hopefully you can save me. I am writing some softwear in C# to communicate over serial with a hardware device.

I need to send some commands such as (in hex):
FF 02 10 00 00 F0 93
0xFF = Header
0x02 = Length
0x10 = OpCode
0x00 = Option
0x00 = DataFlags
0xF0 = CRC
0x93 = CRC

NOTE:>>
The same CRC calculation is performed on all serial communications between the host
and the reader. The CRC is calculated on the Data Length, Command, Status Word, and
Data bytes. The header (SOH, 0xFF) is not included in the CRC.
A sample implementation of the CCITT CRC-16 algorithm is shown in this section. The
CRC_calcCrc8() function is written to calculate the CRC one byte at a time, with the
calculated value stored in crc_calc. The crc_calc value must be pre-loaded the first time
the CRC_calcCrc8() function is called with 0xFFFF to initialize the calculated CRC. The
final value of crc_calc is sent as the 16-bit CRC at the end of the message.
<<END NOTE

The above command works fine, but i need to know how the CRC is calculated. I have read the Wiki Pages on CRC and almost evey page i can find online ( even litterd my room with handwritten binary run throughs ) but to no avail. I am missing something fundamental.

I have attached the sample code that came in the documentation of the hardware but its only an example see the NOTE that came with it:
**CRC-16 checksum (high order byte first). CRC polynomial is
CCITT CRC-16, with a preload of 0xFFFF. This does not fully
specify the operation of the CRC.**

So if possible could someone try to explain this to me if you can ...  with well commented code as I am slowly going insane here trying to figure it out !!
A C# example would be nice using the above command.
999 point to the person crazy enough to try to drum this into me =))
Many Thanks,
Richard

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:

/** @fn void CRC_calcCrc8(u16 *crcReg, u16 poly, u16 u8Data)
* @ Standard CRC calculation on an 8-bit piece of data. To make it
* CCITT-16, use poly=0x1021 and an initial crcReg=0xFFFF.
*
* Note: This function allows one to call it repeatedly to continue
* calculating a CRC. Thus, the first time it's called, it
* should have an initial crcReg of 0xFFFF, after which it
* can be called with its own result.
*
* @param *crcRegPointer to current CRC register.
* @param poly Polynomial to apply.
* @param u8Datau8 data to perform CRC on.
* @return None.
*/
void CRC_calcCrc8(u16 *crcReg, u16 poly, u16 u8Data)
{
u16 i;
u16 xorFlag;
u16 bit;
u16 dcdBitMask = 0x80;
for(i=0; i<8; i++)
{
// Get the carry bit. This determines if the polynomial should be
// xor'd with the CRC register.
xorFlag = *crcReg & 0x8000;
// Shift the bits over by one.
*crcReg <<= 1;
// Shift in the next bit in the data byte
bit = ((u8Data & dcdBitMask) == dcdBitMask);
*crcReg |= bit;
// XOR the polynomial
if(xorFlag)
{
*crcReg = *crcReg ^ poly;
}
// Shift over the dcd mask
dcdBitMask >>= 1;
}
}