一、stm32的CRC
8 V1 j1 y( n8 `  F- W: F        1.1 CRC的简介及MCU关联说明
5 n3 H# J: Z* s8 I        STM32的CRC(Cyclic Redundancy Check，循环冗余校验)计算单元使用一个固定的多项式发生器，从一个32位的数据字产生一个CRC码。在业务开发应用中，会基于CRC的技术用于验证数据传输或存储完整性。在EN/IEC60335-1标准的范围内，它们提供了一种验证闪存（flash）完整性的方法。CRC计算单元帮助计算运行时软件的签名，并与在链接和生成该软件时产生的签名比较验证。
cubeIDE开发， stm32调试信息串口通信输出显示_py_free的博客-CSDN博客_调试信息输出到串口

; v8 x; l5 H! i9 U9 z% D) g4 j0 ]        现双击.ioc文件，打开CubeMX配置界面，开启CRC计算功能，参数保持默认设置。

/ C8 H1 g$ W! j9 D" M% e, R

         保存及生成输出代码

        2.2 CRC的HLA库分析
        cubeMX生成代码时，会在Core源码目录下的Inc及Src目录，分别生成crc.h和crc.c驱动文件。
3 l! x/ z1 ?6 p9 U
        在crc.c文件中，主要定义了MX_CRC_Init函数和HAL_CRC_MspInit函数。MX_CRC_Init主要做两件事情，一是将CubeMX上配置的参数传递给CRC缓存Init和生成CRC句柄Instance(寄存器)，二是调用HLA库的HAL_CRC_Init来实现真正的初始化设定。HAL_CRC_MspInit是HLA内的弱函数，根据实际配置CubeMX会生成新的函数，完成真正的MCU底层设置任务（MspInit，MCU Specific Package init，即指和MCU相关的初始化），覆盖原来的弱函数，而在HAL_CRC_Init函数中会调用到HAL_CRC_MspInit函数。



8 ~; w1 b" o' w( b" |* k+ R- i0 [& ?         在stm32l4xx_hal_crc.c源文件中定义了HAL_CRC_Init函数，它做以下事情：诊断配置参数是否合规；调用HAL_CRC_MspInit函数完成CRC时钟开启；最后将依据参数写入CRC寄存器，如果采用默认多项式参数，写入默认多项式数值，否则调用多项式配置函数，写入用户定义数值。
: O% r- j7 A- {' \) \  B. B


         再回到crc.c内，HAL_CRC_MspInit函数实现了CRC时钟启动设置。

( z0 c1 M7 {; j+ Q" v+ U+ Z, V1 Q

         另外HLA库提供了用户自定义设置多项式参数、输入数据反转及输入数据反转的函数，方便开发这在程序代码中按需变更CRC计算方式，这些函数作为扩展功能放置在stm32l4xx_hal_crc_ex.h/c内。

/ [! q4 X7 w$ b8 K
5 ?1 ~0 L: H7 u" q
         2.3 CRC计算功能及调用设计
, \7 n: I  |) c- O8 u        在stm32l4xx_hal_crc.c源文件除了定义初始化功外，还定义了CRC计算功能函数HAL_CRC_Accumulate和HAL_CRC_Calculate，HAL_CRC_Accumulate函数使用先前的CRC值和新的CRC值的组合来计算8、16或32位数据缓冲器的7、8、16和32位CRC值；HAL_CRC_Calculate独立于先前的CRC值，计算8、16或32位数据缓冲器的7、8、16和32位CRC值，因此它不同于HAL_CRC_Accumulate的部分是每次计算一组数据前，都会进行数据寄存器重置

  J8 [  p& \( s' G# b9 L
( i9 G( \$ N6 O( R7 _
/ K* G& @# K2 n; \

         在main.c文件中，加入驱动文件支持

1. /* Private includes ----------------------------------------------------------*/
   
2. /* USER CODE BEGIN Includes */
   5 Y+ p3 v6 N- j5 k" T$ i2 @
3. #include "../../ICore/key/key.h"
   & ^) r% Y" g0 A( x7 s
4. #include "../../ICore/led/led.h"
   
5. #include "../../ICore/print/print.h"
   
6. #include "../../ICore/usart/usart.h"
   
7. #include "../../ICore/delay/delay.h"
   
8. /* USER CODE END Includes */

复制代码

( Q+ t; P7 ^8 ^9 n& W
        在main.c文件中，加入CRC句柄（寄存器）声明
% B3 d+ @" a: H- s' C$ K. b; L  v

1. /* Private user code ---------------------------------------------------------*/
   
2. /* USER CODE BEGIN 0 */
   ' i" K; t: c9 |& S  @) F0 C
3. extern CRC_HandleTypeDef hcrc;
   
4. /* USER CODE END 0 */

复制代码

1 s$ K" Z7 n) M8 L        在main函数中，加入外设驱动启用（主要是串口调试中断开启）及相关初始设置，添加了一组3个长度32bit宽的数据数组用于测试。

1. /* Initialize all configured peripherals */
   
2.   MX_GPIO_Init();
   * L1 o8 O$ c9 {  _  @1 |/ p# n! Q
3.   MX_LPUART1_UART_Init();
   8 F; I# W7 o+ K9 l' e
4.   MX_CRC_Init();
   - {. [5 A! D5 D6 w2 |
5.   /* USER CODE BEGIN 2 */
   
6.   ResetPrintInit(&hlpuart1);
   
7.   HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData, 1); //再开启接收中断
   
8.   HLPUSART_RX_STA = 0;
   
9.   //
   . W" }, W+ |) I2 Y$ h
10.   printf("app restart now!\r\n");
    
11.   uint32_t crc_input[3] = {0X12345678,0X23456789,0X34567890};
    ; E6 i, j5 W* B4 p1 }, \, `
12.   uint32_t crc_output = 0x00;
    
13.   uint32_t crc_index = 0;
    7 v$ X( E' T( ?: ~( q! J4 d( l, m4 }
14.   uint8_t crc_mode = 0;
    * P4 o! \  h: x# V& K- K& P
15.   /* USER CODE END 2 */

复制代码

       在main函数循环体中，通过按钮调用CRC计算功能，并通过lpuar1串口输出显示计算结果。
% x8 ?. r& }* S. ^7 ^& ~

1. /* Infinite loop */
   
2.   /* USER CODE BEGIN WHILE */
   & s1 V/ r2 E1 P, c) F
3.   while (1)
   1 G5 [0 ^: G# ]2 ?
4.   {
   0 l) ~' B0 z- Z$ ]! ^! v" @* Q- E# Q# i
5.             if(HLPUSART_RX_STA&0xC000){//溢出或换行，重新开始
   
6.                     //printf("%.*s\r\n",HLPUSART_RX_STA&0X0FFF, HLPUSART_RX_BUF);
   ' W' q! J  l0 J. g; G& c# P
7.                     HLPUSART_RX_STA=0;//接收错误,重新开始
   
8.                     HAL_Delay(100);//等待
   2 F1 v5 L2 |- x; n
9.             }
     v1 y/ H) n& t# `* @7 Q
10.           if(KEY_0())
    ; d! B  ?, [& F/ I$ J6 H- U
11.           {
    & i( y7 L$ z: u# b5 Z. P
12.                   crc_output = HAL_CRC_Accumulate(&hcrc,crc_input,3);
    ' s3 G* j2 o6 V) f/ r( y" z
13.                   printf("crc_Accumulate_output:0X%08lX\r\n",crc_output);
    
14.           }
    ) C. R" R9 ~, v6 X
15.           if(KEY_1())
    ) }/ p  U1 J  a
16.             {
    
17.                   crc_output = HAL_CRC_Calculate(&hcrc,crc_input,3);
    
18.                   printf("crc_Calculate_output:0X%08lX\r\n",crc_output);
    
19.             }
    % V  [: {* l+ x8 Q! m; O
20.           if(KEY_2())
    2 z3 h& I$ M1 j! p, B
21.             {
    
22.                   crc_mode = (crc_index)%6;
    
23.                   switch(crc_mode){
    * j4 n7 E4 k% W2 a! M
24.                   case 0:
    + o+ T. ~' ]7 H7 a1 Z8 [
25.                           HAL_CRCEx_Output_Data_Reverse(&hcrc,CRC_OUTPUTDATA_INVERSION_ENABLE);
    3 l3 I# g+ o9 c( A
26.                           printf("Output_Data_Reverse:0X%08lXU\r\n",CRC_OUTPUTDATA_INVERSION_ENABLE);
    : n% b2 b1 c: G  p: @
27.                           break;
    - j& }# y, X. _" u" I3 l) W' e
28.                   case 1:
    
29.                           HAL_CRCEx_Output_Data_Reverse(&hcrc,CRC_OUTPUTDATA_INVERSION_DISABLE);
    
30.                           printf("Output_Data_Reverse:0X%08XU\r\n",CRC_OUTPUTDATA_INVERSION_DISABLE);
    / z. {0 n) N8 R% f8 b2 E
31.                           break;
    
32.                   case 2:
    
33.                           HAL_CRCEx_Input_Data_Reverse(&hcrc,CRC_INPUTDATA_INVERSION_BYTE);
    $ i3 h0 Q# [0 ]7 ?1 r
34.                           printf("Input_Data_Reverse:0X%08lXU\r\n",CRC_INPUTDATA_INVERSION_BYTE);
    + B5 e9 |; f4 U, H: G8 \" m: I
35.                             break;
    # O# x  \" H# H7 Y% n8 j: ]. N/ s- Y
36.                   case 3:
    
37.                           HAL_CRCEx_Input_Data_Reverse(&hcrc,CRC_INPUTDATA_INVERSION_HALFWORD);
    & H+ v# y' Y) P2 z7 G6 U
38.                           printf("Input_Data_Reverse:0X%08lXU\r\n",CRC_INPUTDATA_INVERSION_HALFWORD);
    
39.                           break;
    0 a' s" `' V6 i, v$ r6 I- A
40.                   case 4:
    
41.                           HAL_CRCEx_Input_Data_Reverse(&hcrc,CRC_INPUTDATA_INVERSION_WORD);
    
42.                           printf("Input_Data_Reverse:0X%08lXU\r\n",CRC_INPUTDATA_INVERSION_WORD);
    ! w! d. S# Y, E$ `
43.                             break;
    
44.                   case 5:
    
45.                           HAL_CRCEx_Polynomial_Set(&hcrc,DEFAULT_CRC32_POLY,CRC_POLYLENGTH_16B);
    
46.                           printf("Polynomial_Set:0X%04XU\r\n",DEFAULT_CRC32_POLY);
    9 ~- u3 B5 O* z" W4 X+ X+ A& d
47.                             break;
    
48.                   default:
    
49.                           break;
    
50.                   }
    / h1 j# ~# R- D6 R0 w% ~
51.                   crc_index++;
    
52.             }
    $ y3 ^; b( O% P* B4 k
53.     /* USER CODE END WHILE */

复制代码

2 E7 M+ P' R# }4 x  U  [, p三、编译及测试
. R+ P3 `) _. t8 M1 k5 `: @        3.1 编译下载

; K/ M  ]# C* |3 c6 q6 {
8 @8 r9 r6 i% I
        3.2 测试
. M$ L: u2 n1 y( n6 q+ F: u        程序开启时，默认多项式参数是0x04C11DB7U，无输入、输出反转。每按键一次KEY2改变输入反转模式或输出反转模式或多项式参数 ，然后各按键一次KEY0和KEY1， log输出如下：



3 [: L4 b9 T/ x9 y! [( j) \         案例只是抛砖引玉，更多CRC功能及应用拓展请自行上手代码实践。
————————————————
2 w* c. X! B2 z4 U版权声明：py_free-物联智能
) y7 l2 J* h% q$ I8 }如有侵权请联系删除
+ H, `% T. u* @% V

7 G% @$ G' c$ D5 x0 c/ ^  W; t! X/ l

感谢分享 我想请问一下怎么用自带的CRC计算CRC16 数组类型是uint8的

uint32_t HAL_CRC_Calculate(CRC_HandleTypeDef *hcrc, uint32_t pBuffer[], uint32_t BufferLength); //只允许调用这个
static uint32_t CRC_Handle_16(CRC_HandleTypeDef *hcrc, uint16_t pBuffer[], uint32_t BufferLength);//调用需要修改static属性 不然不让用