TMS320F28377D: VCU2 CRC vs manual calculation

/*
 * CRC16.c
 *
 *  Created on: 22 ���. 2018 �.
 *      Author: Griffin
 */


//*****************************************************************************
// includes
//*****************************************************************************
#include "crc_tbl.h"
#include "vcu2_types.h"
#include "vcu2_crc.h"
#include "crctable0x8005.h"

//!
//! \defgroup CRC16_EXAMPLES Cyclic Redundancy Check 16-bit Example

//!
//! \ingroup CRC16_EXAMPLES
// @{

//*****************************************************************************
// defines
//*****************************************************************************
//#define     NBYTES        (9)
//#define     NWORDS        (5)
#define     NBYTES        (2)
#define     NWORDS        (1)
//*****************************************************************************
// globals
//*****************************************************************************
#ifdef __cplusplus
#pragma DATA_SECTION("testInput")
#else
#pragma DATA_SECTION(testInput,"testInput")
#endif //__cplusplus

//\brief test input
//
// This vector is declared as a static const in order for the linker to
// be able to run the CRC algorithm on it. It needn't be either static
// or const for the C and VCU routines
//
static const uint16_t testInput[NWORDS] =
{
    0x41AF,
    //0x3231, 0x3433, 0x3635, 0x3837, 0x0039,
};

// \brief linker generated object(CRC table)
//
extern CRC_TABLE linkerCrcTable;
// \brief linker generated "run" location for the CRC table object
//
extern uint16_t crcTableRun;
// \brief linker generated "load" location for the CRC table object
//
extern uint16_t crcTableLoad;
// \brief linker generated "size" label indicating the size of the CRC table
// object
//
extern uint16_t crcTableSize;
// \brief object of the structure CRC_Obj
//
CRC_Obj    CRC;
// \brief handle(pointer) to the CRC object
//
CRC_Handle handleCRC;
// \brief A single record(element) from the CRC table object
//
CRC_RECORD linkerCrcRecord;
// \brief pointer to the CRC table object
//
CRC_TABLE *pLinkerCrcTable;
// \brief linker generated variables defining the load and run placements
// of the testInput vector
//
extern uint32_t testInputLoadStart, testInputLoadSize, testInputRunStart;


uint16_t pass = 0;
uint16_t fail = 0;
//*****************************************************************************
// Function Prototypes
//*****************************************************************************

//*****************************************************************************
// function definitions
//*****************************************************************************

//!
//! \brief main routine for the 16-bit CRC example
//! \return returns a 1
//!
//! This example shows how to
//! -# use the vcu2 supported 16-bit CRC routines from the library
//! -# use a C based table lookup routine to run a 16-bit CRC check using
//!    any 16-bit polynomial
//! -# demonstrate the link time CRC generation(using the
//!    polynomials 0x8005) on a specified section of memory
//!
//! \note The variables used in the example are the same used in the CRC-8
//! example and are not documented here again.
//!
void Calculate_CRC16(void)
{
    // Locals
    uint32_t crcResultC_1;

    //*************************************************************************
    // Example #1: 128 bytes(x8, even), parity: low byte first
    //*************************************************************************
    //! \b Example \b #1, \b Part \b 1
    //! In this section we run a table lookup CRC on the vector testInput. The
    //! table is specified in the header files "CrcTable0x8005.h"
    //! The parity chosen was CRC_parity_even indicating that the CRC will start
    //! from the low byte of the first word.
    //! \code
    //************************************************************************
    // Step 1: Copy the test input vector from its load location to the run location.
    // This is necessary since the section was declared within a UNION in the linker
    // command file
    memcpy((uint32_t *)&testInputRunStart, (uint32_t *)&testInputLoadStart,
            (uint32_t)&testInputLoadSize );

    // Step 2: Initialize the CRC object
    CRC.seedValue    = 0xFFFF;//INIT_CRC16;
    CRC.nMsgBytes    = NBYTES;
    CRC.parity       = CRC_parity_even;
    CRC.crcResult    = 0;
    CRC.pMsgBuffer   = (uint16_t *)&testInput[0];
    CRC.pCrcTable    = (uint16_t *)&crc16P1Table[0];
    CRC.init         = (void (*)(void *))CRC_init16Bit;
    CRC.run          = (void (*)(void *))CRC_run16BitTableLookupC;

    // Step 3: Initialize the handle
    handleCRC = &CRC;

    // Step 4: Run the 16-bit table look-up CRC routine and save the first result
    CRC.init(handleCRC);
    CRC.run(handleCRC);
    crcResultC_1 = CRC.crcResult;

    crcResultC_1 = crcResultC_1 ^ 0xFFFF;
}

unsigned int sciaOut[2] =
{
     0x00AF, 0x0041,
};

void MakeCRC16Table(void)
{
    unsigned int r;
    unsigned int i;
    unsigned int j;

    for(i = 0; i < 256; i++)
    {
        r = ((unsigned int) i) << 8;
        for(j = 0; j < 8; j++)
        {
            if(r & (1u << 15)) r= (r << 1) ^ 0x8005;
            else r = r << 1;
        }
        crc16Table[i] = r;
   }
}

unsigned int GetCRC16(unsigned int *buf, unsigned int len)
{
    unsigned int crc;

    crc = 0xFFFF;

    while(len--)
    {
        crc = crc16Table[((crc >> 8) ^ *buf++) & 0xFF] ^ (crc << 8);
    }
    crc ^= 0xFFFF;
    return crc;
}

unsigned int GetCRC16_P(unsigned int *buf, unsigned int len)
{
    unsigned int crc;
    crc = 0xFFFF;

    while(len--)
    {
        crc = crc16Table[(crc >> 8) & 0xFF] ^ ((crc << 8) | *buf++);
    }

    crc = crc16Table[(crc >> 8) & 0xFF] ^ (crc << 8);
    crc = crc16Table[(crc >> 8) & 0xFF] ^ (crc << 8);

    crc ^= 0xFFFF;
    return crc;
}