text: /**
    ******************************************************************************
    * @file    Examples_LL/CRC/CRC_CalculateAndCheck/Src/main.c
    * @author  MCD Application Team
    * @brief   This example describes how to use CRC peripheral for generating CRC value
    *          for an input data Buffer using the STM32L4xx CRC LL API.
    *          Peripheral initialization done using LL unitary services functions.
    ******************************************************************************
    * @attention
    *
    * <h2><center>&copy; COPYRIGHT(c) 2017 STMicroelectronics</center></h2>
    *
    * Redistribution and use in source and binary forms, with or without modification,
    * are permitted provided that the following conditions are met:
    *   1. Redistributions of source code must retain the above copyright notice,
    *      this list of conditions and the following disclaimer.
    *   2. Redistributions in binary form must reproduce the above copyright notice,
    *      this list of conditions and the following disclaimer in the documentation
    *      and/or other materials provided with the distribution.
    *   3. Neither the name of STMicroelectronics nor the names of its contributors
    *      may be used to endorse or promote products derived from this software
    *      without specific prior written permission.
    *
    * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
    * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
    * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
    * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
    * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
    * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *
    ******************************************************************************
    */
  
  /* Includes ------------------------------------------------------------------*/
  #include "main.h"
  
  /** @addtogroup STM32L4xx_LL_Examples
    * @{
    */
  
  /** @addtogroup CRC_CalculateAndCheck
    * @{
    */
  
  /* Private typedef -----------------------------------------------------------*/
  
  /* Private define ------------------------------------------------------------*/
  #define BUFFER_SIZE    39   /* 9 u32 + 1 u16 + 1 u8 */
  
  /* Private macro -------------------------------------------------------------*/
  
  /* Private variables ---------------------------------------------------------*/
  /* Used for storing CRC Value */
  __IO uint32_t uwCRCValue = 0;
  
  
  static const uint8_t aDataBuffer[BUFFER_SIZE] =
  {
    0x21, 0x10, 0x00, 0x00, 0x63, 0x30, 0x42, 0x20, 0xa5, 0x50, 0x84, 0x40,
    0xe7, 0x70, 0xc6, 0x60, 0x4a, 0xa1, 0x29, 0x91, 0x8c, 0xc1, 0x6b, 0xb1,
    0xce, 0xe1, 0xad, 0xd1, 0x31, 0x12, 0xef, 0xf1, 0x52, 0x22, 0x73, 0x32,
    0xa1, 0xb2, 0xc3
  };
  
  /* Expected CRC Value */
  uint32_t uwExpectedCRCValue = 0xA9866043;
  
  /* Private function prototypes -----------------------------------------------*/
  void     SystemClock_Config(void);
  void     Configure_CRC(void);
  uint32_t Calculate_CRC(uint32_t);
  void     CheckCRCResultValue(void);
  void     LED_Init(void);
  void     LED_On(void);
  void     LED_Blinking(uint32_t Period);
  
  /* Private functions ---------------------------------------------------------*/
  
  /**
    * @brief  Main program
    * @param  None
    * @retval None
    */
  int main(void)
  {
    /* Configure the system clock to 80 MHz */
    SystemClock_Config();
  
    /* Initialize LED2 */
    LED_Init();
  
    /* Configure CRC (CRC IP configuration using default Polynomial value) */
    Configure_CRC();
  
    /* Perform CRC calculation on data contained in aDataBuffer */
    uwCRCValue = Calculate_CRC(BUFFER_SIZE);
  
    /* Check if CRC computed result value is equal to expected one */
    CheckCRCResultValue();
  
    /* Infinite loop */
    while (1)
    {
    }
  }
  
  /**
    * @brief  This function configures CRC Instance.
    * @note   This function is used to :
    *         -1- Enable CRC Peripheral clock
    *         -2- Configure CRC functional parameters.
    * @note   Peripheral configuration is minimal configuration from reset values.
    *         Thus, some useless LL unitary functions calls below are provided as
    *         commented examples - setting is default configuration from reset.
    * @param  None
    * @retval None
    */
  void Configure_CRC(void)
  {
  
    /* (1) Enable peripheral clock for CRC                   *********************/
    LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_CRC);
  
    /* (2) Configure CRC functional parameters  ********************************/
  
    /* Configure CRC calculation unit with default generating polynomial, 32-bit */
    /* Reset value is LL_CRC_DEFAULT_CRC32_POLY */
    // LL_CRC_SetPolynomialCoef(CRC, LL_CRC_DEFAULT_CRC32_POLY);  
    /* Reset value is LL_CRC_POLYLENGTH_32B */
    // LL_CRC_SetPolynomialSize(CRC, LL_CRC_POLYLENGTH_32B);
    
    /* Initialize default CRC initial value */
    /* Reset value is LL_CRC_DEFAULT_CRC_INITVALUE */
    // LL_CRC_SetInitialData(CRC, LL_CRC_DEFAULT_CRC_INITVALUE);  
    
    /* Set input data inversion mode : No inversion*/
    /* Reset value is LL_CRC_INDATA_REVERSE_NONE */
    // LL_CRC_SetInputDataReverseMode(CRC, LL_CRC_INDATA_REVERSE_NONE);
    
    /* Set output data inversion mode : No inversion */
    /* Reset value is LL_CRC_OUTDATA_REVERSE_NONE */
    // LL_CRC_SetOutputDataReverseMode(CRC, LL_CRC_OUTDATA_REVERSE_NONE);
  }
  
  /**
    * @brief  This function performs CRC calculation on BufferSize bytes from input data buffer aDataBuffer.
    * @param  BufferSize Nb of bytes to be processed for CRC calculation
    * @retval 32-bit CRC value computed on input data buffer
    */
  uint32_t Calculate_CRC(uint32_t BufferSize)
  {
    register uint32_t data = 0;
    register uint32_t index = 0;
  
    /* Compute the CRC of Data Buffer array*/
    for (index = 0; index < (BufferSize / 4); index++)
    {
      data = (uint32_t)((aDataBuffer[4 * index + 3] << 24) | (aDataBuffer[4 * index + 2] << 16) | (aDataBuffer[4 * index + 1] << 8) | aDataBuffer[4 * index]);
      LL_CRC_FeedData32(CRC, data);
    }
    
    /* Last bytes specific handling */
    if ((BUFFER_SIZE % 4) != 0)
    {
      if  (BUFFER_SIZE % 4 == 1)
      {
        LL_CRC_FeedData8(CRC, aDataBuffer[4 * index]);
      }
      if  (BUFFER_SIZE % 4 == 2)
      {
        LL_CRC_FeedData16(CRC, (uint16_t)((aDataBuffer[4 * index + 1]<<8) | aDataBuffer[4 * index]));
      }
      if  (BUFFER_SIZE % 4 == 3)
      {
        LL_CRC_FeedData16(CRC, (uint16_t)((aDataBuffer[4 * index + 1]<<8) | aDataBuffer[4 * index]));
        LL_CRC_FeedData8(CRC, aDataBuffer[4 * index + 2]);
      }
    }
  
    /* Return computed CRC value */
    return(LL_CRC_ReadData32(CRC));
  }
  
  /**
    * @brief  Check CRC computation result value.
    * @param  None
    * @retval None
    */
  void CheckCRCResultValue(void)
  {
    /* Compare the CRC value to the Expected one */
    if (uwCRCValue != uwExpectedCRCValue)
    {
      /* Wrong CRC value: Set LED2 to Blinking mode (Error) */
      LED_Blinking(LED_BLINK_ERROR);
    }
    else
    {
      /* Right CRC value: Turn LED2 on */
      LED_On();
    }
  }
  
  /**
    * @brief  Initialize LED2.
    * @param  None
    * @retval None
    */
  void LED_Init(void)
  {
    /* Enable the LED2 Clock */
    LED2_GPIO_CLK_ENABLE();
  
    /* Configure IO in output push-pull mode to drive external LED2 */
    LL_GPIO_SetPinMode(LED2_GPIO_PORT, LED2_PIN, LL_GPIO_MODE_OUTPUT);
    /* Reset value is LL_GPIO_OUTPUT_PUSHPULL */
    //LL_GPIO_SetPinOutputType(LED2_GPIO_PORT, LED2_PIN, LL_GPIO_OUTPUT_PUSHPULL);
    /* Reset value is LL_GPIO_SPEED_FREQ_LOW */
    //LL_GPIO_SetPinSpeed(LED2_GPIO_PORT, LED2_PIN, LL_GPIO_SPEED_FREQ_LOW);
    /* Reset value is LL_GPIO_PULL_NO */
    //LL_GPIO_SetPinPull(LED2_GPIO_PORT, LED2_PIN, LL_GPIO_PULL_NO);
  }
  
  /**
    * @brief  Turn-on LED2.
    * @param  None
    * @retval None
    */
  void LED_On(void)
  {
    /* Turn LED2 on */
    LL_GPIO_SetOutputPin(LED2_GPIO_PORT, LED2_PIN);
  }
  
  /**
    * @brief  Set LED2 to Blinking mode for an infinite loop (toggle period based on value provided as input parameter).
    * @param  Period : Period of time (in ms) between each toggling of LED
    *   This parameter can be user defined values. Pre-defined values used in that example are :
    *     @arg LED_BLINK_FAST : Fast Blinking
    *     @arg LED_BLINK_SLOW : Slow Blinking
    *     @arg LED_BLINK_ERROR : Error specific Blinking
    * @retval None
    */
  void LED_Blinking(uint32_t Period)
  {
    /* Toggle IO in an infinite loop */
    while (1)
    {
      LL_GPIO_TogglePin(LED2_GPIO_PORT, LED2_PIN);  
      LL_mDelay(Period);
    }
  }
  
  /**
    * @brief  System Clock Configuration
    *         The system Clock is configured as follows :
    *            System Clock source            = PLL (MSI)
    *            SYSCLK(Hz)                     = 80000000
    *            HCLK(Hz)                       = 80000000
    *            AHB Prescaler                  = 1
    *            APB1 Prescaler                 = 1
    *            APB2 Prescaler                 = 1
    *            MSI Frequency(Hz)              = 4000000
    *            PLL_M                          = 1
    *            PLL_N                          = 40
    *            PLL_R                          = 2
    *            Flash Latency(WS)              = 4
    * @param  None
    * @retval None
    */
  void SystemClock_Config(void)
  {
    /* MSI configuration and activation */
    LL_FLASH_SetLatency(LL_FLASH_LATENCY_4);
    LL_RCC_MSI_Enable();
    while(LL_RCC_MSI_IsReady() != 1) 
    {
    };
    
    /* Main PLL configuration and activation */
    LL_RCC_PLL_ConfigDomain_SYS(LL_RCC_PLLSOURCE_MSI, LL_RCC_PLLM_DIV_1, 40, LL_RCC_PLLR_DIV_2);
    LL_RCC_PLL_Enable();
    LL_RCC_PLL_EnableDomain_SYS();
    while(LL_RCC_PLL_IsReady() != 1) 
    {
    };
    
    /* Sysclk activation on the main PLL */
    LL_RCC_SetAHBPrescaler(LL_RCC_SYSCLK_DIV_1);
    LL_RCC_SetSysClkSource(LL_RCC_SYS_CLKSOURCE_PLL);
    while(LL_RCC_GetSysClkSource() != LL_RCC_SYS_CLKSOURCE_STATUS_PLL) 
    {
    };
    
    /* Set APB1 & APB2 prescaler*/
    LL_RCC_SetAPB1Prescaler(LL_RCC_APB1_DIV_1);
    LL_RCC_SetAPB2Prescaler(LL_RCC_APB2_DIV_1);
  
    /* Set systick to 1ms in using frequency set to 80MHz */
    /* This frequency can be calculated through LL RCC macro */
    /* ex: __LL_RCC_CALC_PLLCLK_FREQ(__LL_RCC_CALC_MSI_FREQ(LL_RCC_MSIRANGESEL_RUN, LL_RCC_MSIRANGE_6), 
                                    LL_RCC_PLLM_DIV_1, 40, LL_RCC_PLLR_DIV_2)*/
    LL_Init1msTick(80000000);
    
    /* Update CMSIS variable (which can be updated also through SystemCoreClockUpdate function) */
    LL_SetSystemCoreClock(80000000);
  }
  
  #ifdef  USE_FULL_ASSERT
  
  /**
    * @brief  Reports the name of the source file and the source line number
    *         where the assert_param error has occurred.
    * @param  file: pointer to the source file name
    * @param  line: assert_param error line source number
    * @retval None
    */
  void assert_failed(char *file, uint32_t line)
  {
    /* User can add his own implementation to report the file name and line number,
       ex: printf("Wrong parameters value: file %s on line %d", file, line) */
  
    /* Infinite loop */
    while (1)
    {
    }
  }
  #endif
  
  /**
    * @}
    */
  
  /**
    * @}
    */
  
  /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
  