MSP430实现循环冗余算法

; Code for application report slaa221 - "CRC Implementation withMSP430"
;
; E.Lenchak
; Texas Instruments, Inc
; March 2004
; Built with IAR Embedded Workbench Version: 3.20A
;******************************************************************************
; THIS PROGRAM IS PROVIDED "AS IS". TI MAKES NO WARRANTIES OR
; REPRESENTATIONS, EITHER EXPRESS, IMPLIED OR STATUTORY,
; INCLUDING ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
; FOR A PARTICULAR PURPOSE, LACK OF VIRUSES, ACCURACY OR
; COMPLETENESS OF RESPONSES, RESULTS AND LACK OF NEGLIGENCE.
; TI DISCLAIMS ANY WARRANTY OF TITLE, QUIET ENJOYMENT, QUIET
; POSSESSION, AND NON-INFRINGEMENT OF ANY THIRD PARTY
; INTELLECTUAL PROPERTY RIGHTS WITH REGARD TO THE PROGRAM OR
; YOUR USE OF THE PROGRAM.
;
; IN NO EVENT SHALL TI BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
; CONSEQUENTIAL OR INDIRECT DAMAGES, HOWEVER CAUSED, ON ANY
; THEORY OF LIABILITY AND WHETHER OR NOT TI HAS BEEN ADVISED
; OF THE POSSIBILITY OF SUCH DAMAGES, ARISING IN ANY WAY OUT
; OF THIS AGREEMENT, THE PROGRAM, OR YOUR USE OF THE PROGRAM.
; EXCLUDED DAMAGES INCLUDE, BUT ARE NOT LIMITED TO, COST OF
; REMOVAL OR REINSTALLATION, COMPUTER TIME, LABOR COSTS, LOSS
; OF GOODWILL, LOSS OF PROFITS, LOSS OF SAVINGS, OR LOSS OF
; USE OR INTERRUPTION OF BUSINESS. IN NO EVENT WILL TIS
; AGGREGATE LIABILITY UNDER THIS AGREEMENT OR ARISING OUT OF
; YOUR USE OF THE PROGRAM EXCEED FIVE HUNDRED DOLLARS
; (U.S.$500).
;
; Unless otherwise stated, the Program written and copyrighted
; by Texas Instruments is distributed as "freeware". You may,
; only under TIs copyright in the Program, use and modify the
; Program without any charge or restriction. You may
; distribute to third parties, provided that you transfer a
; copy of this license to the third party and the third party
; agrees to these terms by its first use of the Program. You
; must reproduce the copyright notice and any other legend of
; ownership on each copy or partial copy, of the Program.
;
; You acknowledge and agree that the Program contains
; copyrighted material, trade secrets and other TI proprietary
; information and is protected by copyright laws,
; international copyright treaties, and trade secret laws, as
; well as other intellectual property laws. To protect TIs
; rights in the Program, you agree not to decompile, reverse
; engineer, disassemble or otherwise translate any object code
; versions of the Program to a human-readable form. You agree
; that in no event will you alter, remove or destroy any
; copyright notice included in the Program. TI reserves all
; rights not specifically granted under this license. Except
; as specifically provided herein, nothing in this agreement
; shall be construed as conferring by implication, estoppel,
; or otherwise, upon you, any license or other right under any
; TI patents, copyrights or trade secrets.
;
; You may not use the Program in non-TI devices.
;
;******************************************************************************/

/**********************************************************************************
FUNCTIONS: 16/32-bit CRC Algorithms, bitwsie and table methods
ARGUMENTS: "bitwise algorithm function signature"
return: CRC
arg1: CRC init value
arg2: CRC generator polynomial
arg3: pointer to the message
arg4: size of message in bytes

"table-based algorithm function signature"
return: CRC
arg1: CRC init value
arg2: pointer to CRC table (specific to generator polynomial)
arg3: pointer to the message
arg4: size of message in bytes
***********************************************************************************/

#ifdef __ICC430__
#include "msp430x16x.h"
#endif

#include "..inccrc.h"

/**************************************
CRC MEMBERS (FUNCTIONS)
**************************************/

// this is anequivalent C implementation to the assembly implementation
unsigned short crc16MakeBitwise(unsigned short crc, unsigned short poly,
unsigned char *pmsg, unsigned int msg_size)
{
unsigned int i, j, carry;
unsigned char msg;
unsigned short temp;

temp = *pmsg << 8;
temp = *pmsg ;
crc ^= temp;

for(i = 0 ; i < msg_size-2 ; i )
{
msg = *pmsg ;

for(j = 0 ; j < 8 ; j )
{
carry = crc & 0x8000;
crc = (crc << 1) (msg >> 7);
if(carry) crc ^= poly;
msg <<= 1;
}
}

for(i = 0 ; i < 2 ; i )
{
for(j = 0 ; j < 8 ; j )
{
carry = crc & 0x8000;
crc <<= 1;
if(carry) crc ^= poly;
}
}
return(crc ^ CRC16_FINAL_XOR);
}

// this is a C-optimized implementation
unsigned short crc16MakeBitwise2(unsigned short crc, unsigned short poly,
unsigned char *pmsg, unsigned int msg_size)
{
unsigned int i, j;
unsigned short msg;

for(i = 0 ; i < msg_size ; i )
{
msg = (*pmsg << 8);

for(j = 0 ; j < 8 ; j )
{
if((msg ^ crc) >> 15) crc = (crc << 1) ^ poly;
else crc <<= 1;
msg <<= 1;
}
}

return(crc ^ CRC16_FINAL_XOR);
}

// this is an equivalent C implementation to the assembly implementation
unsigned long crc32MakeBitwise(unsigned long crc, unsigned long poly,
unsigned char *pmsg, unsigned int msg_size)
{
unsigned int i, j, carry;
unsigned char msg;
unsigned long temp;

temp = (unsigned long)(*pmsg ) << 24;
temp = (unsigned long)(*pmsg ) << 16;
temp = (unsigned long)(*pmsg ) << 8;
temp = (unsigned long)(*pmsg );
crc ^= temp;

for(i = 0 ; i < msg_size-4 ; i )
{
msg = *pmsg ;

for(j = 0 ; j < 8 ; j )
{
carry = crc >> 31;
crc = (crc << 1) (msg >> 7);
if(carry) crc ^= poly;
msg <<= 1;
}
}

for(i = 0 ; i < 4 ; i )
{
for(j = 0 ; j < 8 ; j )
{
carry = crc >> 31;
crc <<= 1;
if(carry) crc ^= poly;
}
}

return(crc ^ CRC32_FINAL_XOR);
}

// this is a C-optimized implementation
unsigned long crc32MakeBitwise2(unsigned long crc, unsigned long poly,
unsigned char *pmsg, unsigned int msg_size)
{
unsigned int i, j;
unsigned long msg;

for(i = 0 ; i < msg_size ; i )
{
msg = *pmsg ;
msg <<= 24;

for(j = 0 ; j < 8 ; j )
{
if((msg ^ crc) >> 31) crc = (crc << 1) ^ poly;
else crc <<= 1;
msg <<= 1;
}
}

return(crc ^ CRC32_FINAL_XOR);
}

unsigned short crc16MakeTableMethod(unsigned short crc, TBL_MEM unsigned short *table,
unsigned char *pbuffer, unsigned int length)
{
while(length--)
crc = table[((crc >> 8) ^ *pbuffer )] ^ (crc << 8); // normal

return(crc ^ CRC16_FINAL_XOR);
}

unsigned short crc16rMakeTableMethod(unsigned short crc, TBL_MEM unsigned short *table,
unsigned char *pbuffer, unsigned int length)
{
while(length--)
crc = table[(crc & 0xFF) ^ *pbuffer ] ^ (crc >> 8); // reflected

return(crc ^ CRC16R_FINAL_XOR);
}

unsigned long crc32MakeTableMethod(unsigned long crc, TBL_MEM unsigned long *table,
unsigned char *pbuffer, unsigned int length)
{
while(length--)
crc = table[((crc >> 24) ^ *pbuffer )] ^ (crc << 8); // normal

return(crc ^ CRC32_FINAL_XOR);
}

unsigned long crc32rMakeTableMethod(unsigned long crc, TBL_MEM unsigned long *table,
unsigned char *pbuffer, unsigned int length)
{
while(length--)
crc = table[(crc ^ *pbuffer ) & 0xFFL] ^ (crc >> 8); // reflected

return(crc ^ CRC32R_FINAL_XOR);
}

/************************************
CRC UTILITIES
************************************/

void crc16BuildTable(unsigned short *ptable, unsigned short poly)
{
unsigned int i, j;

for(i = 0; i <= 255; i )
{
ptable[i] = i << 8;
for(j = 0; j < 8; j )
ptable[i] = (ptable[i] << 1) ^ (ptable[i] & 0x8000 ? poly : 0);
}
}

void crc32BuildTable(unsigned long *ptable, unsigned long poly)
{
unsigned int i, j;

for(i = 0; i <= 255; i )
{
ptable[i] = (long)i << 24;
for(j = 0; j < 8; j )
ptable[i] = (ptable[i] << 1) ^ (ptable[i] & 0x80000000 ? poly : 0);
}
}

unsigned long bitReflect(unsigned long data, unsigned int width)
{
unsigned long result = 0;
unsigned int i;

for (i = 1; i < (width 1); i )
{
if(data & 1) result = 0x1L << (width - i);
data >>= 1;
}

return result;
}

/************************************ END ***************************************/