MSP430实现循环冗余算法

MSP430实现循环冗余算法
[ 2006-6-18 14:54:59 By: 超越梦想 ]
/******************************************************************************
;   Code for application report slaa221 - "CRC Implementation with MSP430"
;
;   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 TI''S
; 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 TI''s 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 TI''s
; 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 "..\inc\crc.h"
/**************************************
CRC MEMBERS (FUNCTIONS)
**************************************/
// this is an equivalent 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 << 8;
        for(j = 0; j < 8; j++)
            ptable = (ptable << 1) ^ (ptable & 0x8000 ? poly : 0);
    }
}
void crc32BuildTable(unsigned long *ptable, unsigned long poly)
{
unsigned int i, j;
    for(i = 0; i <= 255; i++)
    {
        ptable = (long)i << 24;        
        for(j = 0; j < 8; j++)
            ptable = (ptable << 1) ^ (ptable & 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 ***************************************/