5.5 CRC Guide

The example runs the hardware CRC and a software reference algorithm on the same data set and verifies the hardware computation by comparing the two results.

Data path: DataBuffer, Buffer → CRC32_CalcBufCrc, CRC16_CalcBufCrc write CRC->CRC32DAT, CRC->CRC16DAT and read the results back → GetCRC32_Software, GetCRC16_Software recompute bit by bit → the results are compared and printed by printf

1. Define the checksum data and the polynomials. The data size and the two generator polynomials come from the macros at the top of the file, and both the hardware and the software paths use the same data set.

#define BUFFER_SIZE    114
#define CRC16_DFE_POLY 0x8005
#define CRC32_DFE_POLY 0x04C11DB7

When porting to your own data, change BUFFER_SIZE and the element counts of DataBuffer and Buffer together, and change both macros together when the generator polynomial changes.

2. Enable the CRC clock and run the hardware CRC32 first. After enabling the CRC clock and initialising the serial port, main computes the hardware CRC32 and then the software CRC32, both over DataBuffer.

    /* Enable CRC clock */
    RCC_EnableAHBPeriphClk(RCC_AHB_PERIPH_CRC, ENABLE);

    log_init();

    /* Compute the 32-bit CRC of DataBuffer using hardware */
    CRC32Value = CRC32_CalcBufCrc((uint32_t*)DataBuffer, BUFFER_SIZE);

    /* Compute the 32-bit CRC of DataBuffer using software */
    CRCValue   = GetCRC32_Software((uint32_t*)DataBuffer, BUFFER_SIZE, 0xffffffff);

CRC32_CalcBufCrc only writes each word into CRC->CRC32DAT and reads CRC->CRC32D back; it does not reset CRC32 internally, so the hardware initial value is the reset value 0xFFFF_FFFF of CRC_CRC32DAT, and the software initial value 0xffffffff must match it for the results to be comparable.

3. Recompute bit by bit with the software reference algorithm. GetCRC32_Software shifts each word left bit by bit and XORs the generator polynomial, producing a CRC32 that matches the hardware.

    for (i = 0; i < len; i++)
    {
        xbit = 0x80000000;

        for (bits = 0; bits < 32; bits++)
        {
            if (crc32 & 0x80000000)
            {
                crc32 <<= 1;
                crc32 ^= CRC32_DFE_POLY;
            }
            else
            {
                crc32 <<= 1;
            }

            if (buf[i] & xbit)
            {
                crc32 ^= CRC32_DFE_POLY;
            }

            xbit >>= 1;
        }
    }

This part handles 32-bit words only; when moving to byte or half-word data, the word length, the bit width and the polynomial must all be adjusted together with the hardware side.

4. Compare the results and print the conclusion. The volatile values are read into local variables and compared; equality prints the correct message and otherwise the error message, and the 16-bit path is compared in the same way.

    /* Read volatile values into local variables to avoid undefined access order */
    crc32_hw = CRC32Value;
    crc32_sw = CRCValue;
    if (crc32_hw == crc32_sw)
    {
        printf(" CRC32 calculation is correct! \r\n");
    }
    else
    {
        printf(" CRC32 calculation error! \r\n");
    }

    /* Compute the 16-bit CRC of Buffer using hardware */
    CRC16Value = CRC16_CalcBufCrc((uint8_t*)Buffer, 8);

    /* Compute the 16-bit CRC of Buffer using software */
    CRCValue   = GetCRC16_Software((uint8_t*)Buffer, 8, 0x00);

CRC16_CalcBufCrc first writes CRC->CRC16D to 0x0000 before accumulating, so the software initial value 0x00 matches it; when porting, the length 8 in this block must match the actual element count of Buffer.

Corresponding source files: src/main.c, inc/main.h

The example uses a DMA channel instead of software register writes to move data between the data buffers and the result registers, and judges the checks from the values read back.

Data path: CRC_original_word_data, CRC_original_byte_data → DMA_Init, DMA_EnableChannel move them into CRC->CRC32DAT, CRC->CRC16DAT → CRC32_GetCrc, __CRC16_GetCrc, __CRC16_GetLRC or the DMA reads the results back → printf prints them and they are compared with the expected values

1. Enable the CRC and DMA clocks and reset CRC32. main enables the AHB clocks of both peripherals, initialises the serial port, resets CRC32 and then enters the two test functions.

    /* Enable CRC and DMA clock */
    RCC_EnableAHBPeriphClk(RCC_AHB_PERIPH_CRC | RCC_AHB_PERIPH_DMA, ENABLE);

    log_init();

    printf(" CRC DMA test start.\r\n");

    CRC32_ResetCrc();

    TestCrc32AndDma();
    TestCrc16AndDma();

Both test functions depend on DMA, so the source files of the CRC and DMA drivers must be added to the build together when porting to another project.

2. Move the word data into CRC32 by DMA. The DMA channel moves the 114 words of CRC_original_word_data one by one into the 32-bit CRC data register, and the wait ends on the transfer-complete flag.

    /* Memory -> CRC32DAT */
    DMA_InitStructure.PeriphAddr     = (uint32_t)&CRC->CRC32DAT;
    DMA_InitStructure.MemAddr        = (uint32_t)CRC_original_word_data;
    DMA_InitStructure.Direction      = DMA_DIR_PERIPH_DST;
    DMA_InitStructure.Mem2Mem        = DMA_M2M_ENABLE;
    DMA_InitStructure.MemDataSize    = DMA_MemoryDataSize_Word;
    DMA_InitStructure.PeriphDataSize = DMA_PERIPH_DATA_SIZE_WORD;
    DMA_InitStructure.DMA_MemoryInc  = DMA_MEM_INC_ENABLE;
    DMA_InitStructure.PeriphInc      = DMA_PERIPH_INC_DISABLE;
    DMA_InitStructure.CircularMode   = DMA_MODE_NORMAL;
    DMA_InitStructure.Priority       = DMA_PRIORITY_VERY_HIGH;
    DMA_InitStructure.BufSize        = 114;

    DMA_Init(DMA_CH1, &DMA_InitStructure);
    DMA_EnableChannel(DMA_CH1, ENABLE);
    while (!DMA_GetFlagStatus(DMA_FLAG_TC1, DMA));
    DMA_DeInit(DMA_CH1);

The peripheral address stays fixed on the result register while the memory address increments, so each word enters the CRC in turn; change MemAddr and BufSize together when replacing the buffer, and switch to byte width for byte data.

3. Read the CRC32 result back and compare it with the expected value. After the transfer the result register is read with CRC32_GetCrc and compared with the fixed expected value, and a mismatch prints an error.

    CRC32_Value = CRC32_GetCrc();
    printf("The CRC 32 code after Memory->CRC32DAT DMA transmission is %08x.\r\n", CRC32_GetCrc());

    if (CRC32_Value != 0x379E9F06)
        printf("The CRC 32 code computed through DMA transmission is error, it should be 0x379E9F06.\r\n");

The expected value 0x379E9F06 corresponds to this fixed set of 114 words; the comparison value must be recomputed whenever the data or the polynomial changes.

4. Set the CRC16 initial value, the clear and the big-endian format before transferring. Before the CRC16 transfer the initial value is set, the result is cleared and big-endian is selected, and the 456 bytes are then moved in by byte width.

    __CRC16_SetCrc(0x00);
    __CRC16_SetLRC(0x00);
    __CRC16_SetCleanEnable();
    __CRC16_SetBigEndianFmt();

    /* Memory -> CRC16DAT */
    DMA_InitStructure.PeriphAddr     = (uint32_t)&CRC->CRC16DAT;
    DMA_InitStructure.MemAddr        = (uint32_t)CRC_original_byte_data;
    DMA_InitStructure.Direction      = DMA_DIR_PERIPH_DST;
    DMA_InitStructure.Mem2Mem        = DMA_M2M_ENABLE;
    DMA_InitStructure.MemDataSize    = DMA_MemoryDataSize_Byte;
    DMA_InitStructure.PeriphDataSize = DMA_PERIPH_DATA_SIZE_BYTE;
    DMA_InitStructure.DMA_MemoryInc  = DMA_MEM_INC_ENABLE;
    DMA_InitStructure.PeriphInc      = DMA_PERIPH_INC_DISABLE;
    DMA_InitStructure.CircularMode   = DMA_MODE_NORMAL;
    DMA_InitStructure.Priority       = DMA_PRIORITY_VERY_HIGH;
    DMA_InitStructure.BufSize        = 456;

    DMA_Init(DMA_CH1, &DMA_InitStructure);
    DMA_EnableChannel(DMA_CH1, ENABLE);
    while (!DMA_GetFlagStatus(DMA_FLAG_TC1, DMA));
    DMA_DeInit(DMA_CH1);

__CRC16_SetBigEndianFmt clears the ENDIAN bit so that the data under check is processed from the most significant bit, and __CRC16_SetCleanEnable sets the clear bit so that the result register first takes the default value 0x0000. A different data endianness or initial value changes the CRC16 result directly.

5. Read the CRC16 and LRC results back and compare them. After the transfer the result register and the LRC register are read and compared with the expected values.

    CRC16_Value = __CRC16_GetCrc();
    LRC_Value = __CRC16_GetLRC();

    printf("The CRC 16 code after Memory->CRC16DAT DMA transmission is %04x.\r\n", __CRC16_GetCrc());
    if (CRC16_Value != 0x5268)
        printf("The CRC 16 code computed through DMA transmission is error, it should be 0x5268.\r\n");

    printf("The LRC code after Memory->CRC16DAT DMA transmission is %02x.\r\n", __CRC16_GetLRC());
    if (LRC_Value != 0x00)
        printf("The LRC code computed through DMA transmission is error, it should be 0x00.\r\n");

The CRC and LRC calculations run at the same time, so reading CRC->LRC gives the LRC checksum of the same data set; for this data the expected values are 0x5268 for CRC16 and 0x00 for LRC.

Corresponding source files: src/main.c, src/crc_dma.c, inc/main.h