unsigned long board_unique_crcid_compute (void *in_buf, int in_buf_length,
int flags_32_8)
{
unsigned char *in_buf8;
unsigned long *in_buf32;
unsigned int crc_input, i;
uint32_t crcResult;
in_buf8 = (unsigned char*) in_buf;
if (flags_32_8 == 8)
{ for (i = 0; i < in_buf_length; i++)
u32Buffer[i] = in_buf8[i]; // convert from 8-bit to L.O. 32-bit
// STM32: generate random seed from CRC unit
crcResult = HAL_CRC_Accumulate (&CrcHandle, u32Buffer, 6); // yields 0
crcResult = HAL_CRC_Calculate (&CrcHandle, u32Buffer, 6); // ditto WTF
}
else
{ // is already in 32-bit format - use in place
// STM32: generate random seed from CRC unit
crcResult = HAL_CRC_Accumulate (&CrcHandle, in_buf,
in_buf_length); // yields 0
crcResult = HAL_CRC_Calculate (&CrcHandle, in_buf,
in_buf_length); // ditto WTF
}
_g_crcid_Result = crcResult; // all done, Save results
return (_g_crcid_Result);
}
/**
* @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)
{
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F1xx 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.
- Set NVIC Group Priority to 4
- Low Level Initialization
*/
HAL_Init();
/* Configure the system clock to 24 MHz */
SystemClock_Config();
/* Configure LED3 and LED4 */
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
/*##-1- Configure the CRC peripheral #######################################*/
CrcHandle.Instance = CRC;
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 LED4 on */
Error_Handler();
}
else
{
/* Right CRC value: Turn LED3 on */
BSP_LED_On(LED3);
}
/* Infinite loop */
while (1)
{
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to 180 MHz */
SystemClock_Config();
/* Configure LED1 and LED3 */
BSP_LED_Init(LED1);
BSP_LED_Init(LED3);
/*##-1- Configure the CRC peripheral #######################################*/
CrcHandle.Instance = CRC;
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 on */
Error_Handler();
}
else
{
/* Right CRC value: Turn LED1 on */
BSP_LED_On(LED1);
}
/* Infinite loop */
while (1)
{
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* Enable the CPU Cache */
CPU_CACHE_Enable();
/* STM32F7xx HAL library initialization:
- Configure the Flash ART accelerator on ITCM interface
- 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.
- Set NVIC Group Priority to 4
- Low Level Initialization
*/
HAL_Init();
/* Do nothing : wait for clock configuration first */
/* Configure the system clock to 216 MHz */
SystemClock_Config();
/* Since MFX is used, LED init is done after clock config */
/* Configure LED1 and LED3 */
BSP_LED_Init(LED1);
BSP_LED_Init(LED3);
/*##-1- Configure the CRC peripheral #######################################*/
CrcHandle.Instance = CRC;
/* The default polynomial is used */
CrcHandle.Init.DefaultPolynomialUse = DEFAULT_POLYNOMIAL_ENABLE;
/* 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 32 bits lenght */
CrcHandle.InputDataFormat = CRC_INPUTDATA_FORMAT_WORDS;
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 on */
Error_Handler();
}
else
{
/* Right CRC value: Turn LED1 on */
BSP_LED_On(LED1);
}
/* Infinite loop */
while (1)
{
}
}
/**
* @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)
{
}
}
