/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32L0xx HAL library initialization:
- Configure the Flash prefetch, Flash preread and Buffer caches
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Low Level Initialization
*/
HAL_Init();
/* Configure LED3 */
BSP_LED_Init(LED3);
/* Configure the system clock to 2 Mhz */
SystemClock_Config();
/*##-1- Configure the CRC peripheral #######################################*/
CrcHandle.Instance = CRC;
CrcHandle.Init.DefaultPolynomialUse = DEFAULT_POLYNOMIAL_ENABLE;
CrcHandle.Init.DefaultInitValueUse = DEFAULT_INIT_VALUE_ENABLE;
CrcHandle.Init.InputDataInversionMode = CRC_INPUTDATA_INVERSION_NONE;
CrcHandle.Init.OutputDataInversionMode = CRC_OUTPUTDATA_INVERSION_DISABLE;
CrcHandle.InputDataFormat = CRC_INPUTDATA_FORMAT_WORDS;
/* DeInitializes the CRC peripheral */
HAL_CRC_DeInit(&CrcHandle);
/* Initialise CRC */
HAL_CRC_Init(&CrcHandle);
if(HAL_CRC_Init(&CrcHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Compute the CRC of "aDataBuffer" ###################################*/
uwCRCValue = HAL_CRC_Accumulate(&CrcHandle, (uint32_t *)aDataBuffer, BUFFER_SIZE);
/*##-3- Compare the CRC value to the Expected one ##########################*/
if(uwCRCValue != uwExpectedCRCValue)
{
/* Wrong CRC value: Turn LED3 off */
Error_Handler();
}
else
{
/* Right CRC value: Turn LED3 on */
BSP_LED_On(LED3);
}
/* Infinite loop */
while (1)
{
}
}
void BL_crc_deinit(void)
{
hcrc.Instance = CRC;
// TODO: Check if next statement wil be used in future. Semaphore needed?
if (!HAL_CRC_DeInit(&hcrc))
{
assert_failed((uint8_t *)__FILE__, __LINE__);
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F0xx HAL library initialization:
- Configure the Flash prefetch
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Low Level Initialization
*/
HAL_Init();
/* Configure the system clock to 48 MHz */
SystemClock_Config();
/* Configure LED2 */
BSP_LED_Init(LED2);
/****************************************************************************/
/* */
/* CRC peripheral initialization */
/* */
/****************************************************************************/
CrcHandle.Instance = CRC;
/* The default polynomial is not used. The one to be used must be defined
in CrcHandle.Init.GeneratingPolynomial */
CrcHandle.Init.DefaultPolynomialUse = DEFAULT_POLYNOMIAL_DISABLE;
/* Set the value of the generating polynomial.
The one used in that example is the 7-bit long CRC generating
polynomial X^7 + X^6 + X^5 + X^2 + 1 */
CrcHandle.Init.GeneratingPolynomial = CRC_POLYNOMIAL_7B;
/* The user-defined generating polynomial yields a 7-bit long CRC */
CrcHandle.Init.CRCLength = CRC_POLYLENGTH_7B;
/* The default init value is used */
CrcHandle.Init.DefaultInitValueUse = DEFAULT_INIT_VALUE_ENABLE;
/* The input data are not inverted */
CrcHandle.Init.InputDataInversionMode = CRC_INPUTDATA_INVERSION_NONE;
/* The output data are not inverted */
CrcHandle.Init.OutputDataInversionMode = CRC_OUTPUTDATA_INVERSION_DISABLE;
/* The input data are bytes (8-bit long data) */
CrcHandle.InputDataFormat = CRC_INPUTDATA_FORMAT_BYTES;
/* De-initialize the CRC peripheral */
if (HAL_CRC_DeInit(&CrcHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/* Then, initialize the CRC handle */
if (HAL_CRC_Init(&CrcHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/****************************************************************************/
/* */
/* CRC computation of a first bytes stream */
/* */
/****************************************************************************/
/* The 7-bit long CRC of a 5-byte buffer is computed. After IP initialization,
the CRC calculator is initialized with the default value that is 0x7F for
a 7-bit CRC.
The computed CRC is stored in uint32_t uwCRCValue. The 7-bit long CRC is made of
uwCRCValue 7 LSB bits. */
uwCRCValue = HAL_CRC_Accumulate(&CrcHandle, (uint32_t *)&CRC7_DATA8_TEST5, BUFFER_SIZE_5);
/* Compare the CRC value to the expected one */
if (uwCRCValue != uwExpectedCRCValue_1)
{
/* Wrong CRC value: enter Error_Handler */
Error_Handler();
}
/****************************************************************************/
/* */
/* CRC computation of a second bytes stream */
/* */
/****************************************************************************/
/* The 7-bit long CRC of a 17-byte buffer is computed. The CRC calculator
is not re-initialized, instead the previously computed CRC is used
as initial value. */
uwCRCValue = HAL_CRC_Accumulate(&CrcHandle, (uint32_t *)&CRC7_DATA8_TEST17, BUFFER_SIZE_17);
/* Compare the CRC value to the expected one */
if (uwCRCValue != uwExpectedCRCValue_2)
{
/* Wrong CRC value: enter Error_Handler */
Error_Handler();
}
/****************************************************************************/
/* */
/* CRC computation of a single byte */
/* */
/****************************************************************************/
/* The 7-bit long CRC of a 1-byte buffer is computed. The CRC calculator
is not re-initialized, instead the previously computed CRC is used
as initial value. */
uwCRCValue = HAL_CRC_Accumulate(&CrcHandle, (uint32_t *)&CRC7_DATA8_TEST1, BUFFER_SIZE_1);
/* Compare the CRC value to the expected one */
if (uwCRCValue != uwExpectedCRCValue_3)
{
/* Wrong CRC value: enter Error_Handler */
Error_Handler();
}
/****************************************************************************/
/* */
/* CRC computation of the last bytes stream */
/* */
/****************************************************************************/
/* The 7-bit long CRC of a 2-byte buffer is computed. The CRC calculator
is re-initialized with the default value that is 0x7F for a 7-bit CRC.
This is done with a call to HAL_CRC_Calculate() instead of
HAL_CRC_Accumulate(). */
uwCRCValue = HAL_CRC_Calculate(&CrcHandle, (uint32_t *)&CRC7_DATA8_TEST2, BUFFER_SIZE_2);
/* Compare the CRC value to the expected one */
if (uwCRCValue != uwExpectedCRCValue_4)
{
/* Wrong CRC value: enter Error_Handler */
Error_Handler();
}
else
{
/* Right CRC value: Turn LED2 on */
BSP_LED_On(LED2);
}
/* Infinite loop */
while (1)
{
}
}