Posted on March 13, 2015 at 19:09
O.K. finally I got it working!
The suggested init function was necessary, but not sufficient, there were some more things to do...
To give other users a hand, here's what I did to get it running, step by step:
1. add the init function (and of course, call it from main() )
void
MX_CRC_Init(
void
)
{
hcrc.Instance = CRC;
HAL_CRC_Init(&hcrc);
}
2. uncomment the line
#define HAL_CRC_MODULE_ENABLED
in the header file
stm32f2xx_hal_conf.h
3. to get the CRC peripheral clock enabled (and disabled), the MspInit/MspDeInit functions for the CRC peripheral have to be added in the file
stm32f2xx_hal_msp.c
(Normally done by the STM32CubeMX software.)
void
HAL_CRC_MspInit(CRC_HandleTypeDef* hcrc)
{
if
(hcrc->Instance==CRC)
{
/* USER CODE BEGIN CRC_MspInit 0 */
/* USER CODE END CRC_MspInit 0 */
/* Peripheral clock enable */
__CRC_CLK_ENABLE();
/* USER CODE BEGIN CRC_MspInit 1 */
/* USER CODE END CRC_MspInit 1 */
}
}
void
HAL_CRC_MspDeInit(CRC_HandleTypeDef* hcrc)
{
if
(hcrc->Instance==CRC)
{
/* USER CODE BEGIN CRC_MspDeInit 0 */
/* USER CODE END CRC_MspDeInit 0 */
/* Peripheral clock disable */
__CRC_CLK_DISABLE();
/* USER CODE BEGIN CRC_MspDeInit 1 */
/* USER CODE END CRC_MspDeInit 1 */
}
}
That's all you have to do, to use the CRC peripheral via HAL funtions.
Because I needed to calculate a Gzip / ZMODEM compatible CRC32 on a bytewise organized data stream, I had to write my own function. The the CRC unit only can calculate CRC on whole 32 bit data words, and it shifts the other way round ...
My crc function first tweaks the data written to the CRC peripheral by reversing bitorder of each 32-bit word and also reverses bitorder of the calculated CRC. At last, the CRC value has to be inverted bitwise.
To be able to calculate the CRC of data blocks with lengths not beeing a multiple of 4 byte, I added a small piece of extra software that calculates the CRC of the remaining bytes (at most 3).
Because at most 3 bytes are calculated by software this won't be a performance issue.
my crc function:
/**
* @brief Computes the 32-bit CRC of 8-bit data buffer independently
* of the previous CRC value.
* @param hcrc: CRC handle
* @param p_src: Pointer to the buffer containing the data to be computed
* @param size: size of the buffer to be computed, in bytes
* @retval 32-bit CRC, compatible with Gzip, PKZIP, WINRAR, ZMODEM etc.
*/
uint32_t crc32_calculate(CRC_HandleTypeDef *hcrc, uint8_t *p_src, uint32_t size)
{
uint32_t i;
uint32_t bit;
uint32_t crc32;
// Process Locked
__HAL_LOCK(hcrc);
// Change CRC peripheral state
hcrc->State = HAL_CRC_STATE_BUSY;
// Reset CRC Calculation Unit
__HAL_CRC_DR_RESET(hcrc);
// calculate number of complete 32-bit words
i = size >> 2;
// Enter complete 32-bit-data words to the CRC calculator
while
(i--)
{
// load 32 bit data word and reverse bitorder [.0] -> [0..31]
crc32 = __RBIT(*(uint32_t*)p_src);
// enter data into CRC calculator
hcrc->Instance->DR = crc32;
// set byte pointer to next 32 bit word
p_src += 4;
}
// Change CRC peripheral state
hcrc->State = HAL_CRC_STATE_READY;
// Process Unlocked
__HAL_UNLOCK(hcrc);
// read out calculated CRC and reverse bitorder
crc32 = __RBIT(hcrc->Instance->DR);
// get number of remaining data bytes (max 3)
i = size & 0x03;
// calculate CRC of remaining bytes by software
while
(i--)
{
crc32 ^= (uint32_t)(*p_src++);
for
(bit = 0; bit < 8; bit++)
{
if
(crc32 & 1)
{
// shift and XOR with CRC-polynomial
crc32 = (crc32 >> 1) ^ 0xEDB88320ul;
}
else
{
crc32 >>= 1;
}
}
}
// at last, calculated CRC value has to be inverted bitwise
crc32 = ~crc32;
// return calculated CRC32
return
crc32;
}
Best regards,
Thorsten
