2021年03月10日 | MSP430实现循环冗余算法

/******************************************************************************

;   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__

＃i nclude  "msp430x16x.h"

#endif

＃i nclude "..inccrc.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] = 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)