NV32F100 CRC

初始化CRC

复制

void CRC_Init(CRC_ConfigType *pConfig)

{       

    uint32_t     u32Sc ;

    

    u32Sc      = 0;

    

    SIM->SCGC |= SIM_SCGC_CRC_MASK;   //使能CRC控制模块时钟

    

    u32Sc     |= ((pConfig->bWidth & 0x01)<<24);   //CRC模式选择

    u32Sc     |= CRC_CTRL_TOTR(pConfig->bTransposeReadType & 0x03);  //设置数据读取的转置类型

    u32Sc     |= CRC_CTRL_TOT(pConfig->bTransposeWriteType & 0x03);  //设置数据写入的转置类型

    

    if (pConfig->bFinalXOR)  

    {

        u32Sc |= CRC_CTRL_FXOR_MASK;  //对CRC数据寄存的读取值进行异或操作     

    }

    

    CRC0->CTRL  = u32Sc;



    if ( pConfig->bWidth )      

    {

        CRC0->GPOLY = pConfig->u32PolyData;  //写入32位多项式

    }

    else 

    {

        CRC0->GPOLY_ACCESS16BIT.GPOLYL = pConfig->u32PolyData;  /*!< 仅允许写16位多项式*/             

    }  

    

}     

16位模式下CRC计算函数

复制

uint32_t CRC_Cal16(uint32_t seed, uint8_t *msg, uint32_t sizeBytes)

{

  uint32_t ctrl_reg,data_out,data_in;

  uint8_t  *pCRCBytes;

  uint32_t sizeWords;

  uint32_t i,j;  

  

  /* 设置WaS=1，写入种子值 */

  ctrl_reg  = CRC0->CTRL;

  CRC0->CTRL  = ctrl_reg | CRC_CTRL_WAS_MASK;

  CRC0->ACCESS16BIT.DATAL = seed; 

  

  /* Set WaS=0，准备写入数据*/

  CRC0->CTRL  = ctrl_reg & 0xFD000000; 



  /*等待计算完成*/

  sizeWords = sizeBytes>>1;

  j = 0;

  for(i=0;i<sizeWords;i++){ 

      data_in = (msg[j] << 8) | (msg[j+1]);  /*将数据写入CRC数据寄存器，以16位方式写入*/

      j += 2;

      CRC0->ACCESS16BIT.DATAL =data_in; 

  }

  if (j<sizeBytes)

  { 

     pCRCBytes = (uint8_t*)&CRC0->ACCESS8BIT.DATALL; /*以8位的方式写入剩余的数据*/

     *pCRCBytes++ = msg[j];

  }

  if ((CRC0->CTRL& CRC_CTRL_TOTR_MASK)>1)   //Modify

  {

     data_out=CRC0->ACCESS16BIT.DATAH;  //读出字节转置后16位计算结果

  }

  else

  {

     data_out=CRC0->ACCESS16BIT.DATAL;  //读出16位计算结果

  }

  

  return(data_out);

}

32位模式下CRC计算

复制

uint32_t CRC_Cal32(uint32_t seed, uint8_t *msg, uint32_t sizeBytes)

{  

  uint32_t ctrl_reg,data_out,data_in;

  uint32_t sizeDwords;

  uint8_t  *pCRCBytes;

  uint32_t i,j;

  

 /* 设置WaS=1，写入种子值 */

  ctrl_reg = CRC0->CTRL;

  CRC0->CTRL = ctrl_reg | 0x02000000;

  CRC0->DATA = seed;

 

 /* Set WaS=0，准备写入数据*/

  CRC0->CTRL = ctrl_reg & 0xFD000000;

  

  /*等待数据计算完成*/

  sizeDwords = sizeBytes>>2;

  j = 0;

  for(i=0;i<sizeDwords;i++)

  { 

      data_in = ((msg[j] << 24) | (msg[j+1] << 16) | (msg[j+2] << 8) | msg[j+3]); /*将数据写入CRC数据寄存器，以32方式写入*/

      j += 4;

      CRC0->DATA = data_in; 

  }

  if (j<sizeBytes)

  {

    pCRCBytes = (uint8_t*)&CRC0->ACCESS8BIT.DATALL;    /*以8位的方式写入剩余的数据*/



#if  defined(BYTE_ENABLES_1_2_4_8)    

    

    /*只写单个字节*/  

    for(;j<sizeBytes;j++)

    {     

       *pCRCBytes++ = msg[j];

    }

#elif  defined(BYTE_ENABLES_3_6_C)

    

    /*写入两个字节*/ 

    data_in = 0;

    i = 0;

    for(;j<sizeBytes;j++)

    {     

      data_in = (data_in <<8) | msg[j];

      i++;

      if (i==2)

      {

        i = 0;

        CRC0->ACCESS16BIT.DATAL = data_in;

      }

    }

    if (i==1)

    {

       CRC0->ACCESS8BIT.DATALL = data_in;                /*!< 写入最后一个字节 */

    }

#elif  defined(BYTE_ENABLES_7_E)                         

    /*!< 写入三个字节*/

    data_in = 0;

    i = 0;

    for(;j<sizeBytes;j++)

    {     

      data_in = (data_in <<8) | msg[j];

      i++;

      if (i==3)

      {

        i = 0;

        /*写入第一个字符*/

        CRC0->ACCESS8BIT.DATAHL  = (data_in>>16) & 0xff; /*!< 写入高字的低字节 */

        /*写入最后两个字节*/

        CRC0->ACCESS16BIT.DATAL = data_in & 0x00ffff;    /*!< 写入低字 */

       }

    }

    if ( i == 2)

    {

       CRC0->ACCESS16BIT.DATAL = (data_in);              /*!< 写最后两个字节 */

    }

    else if (i == 1)

    {

       CRC0->ACCESS8BIT.DATALL = data_in;                /*!< 写最后一个字节 */      

    }

#else                                                    /*!< 只写低字节 */

    for(;j<sizeBytes;j++)

    {     

       *pCRCBytes = msg[j];

    }

#endif            

  }

  data_out=CRC0->DATA;    



  return(data_out);   //读出32位计算结果

}

复位CRC模块

复制

void CRC_DeInit(void)

{  

   CRC0->CTRL  = 0x3000000; /*!<设置CRC位32位模式*/ 

   CRC0->DATA  = 0xFFFFFFFF;/*!< 写32位种子值到CRC数据寄存器*/ 

   while(!(CRC0->DATA == 0xFFFFFFFF));

   CRC0->GPOLY = 0x00001021; 

   CRC0->CTRL  = 0;         /*!<CRC控制寄存器清零*/  

   SIM->SCGC &= ~SIM_SCGC_CRC_MASK;

}

CRC控制寄存器位定义

复制

#define CRC_WIDTH_16BIT                 0        /*!< 选择16位CRC协议 */   

#define CRC_WIDTH_32BIT                 1        /*!< 选择32位CRC协议 */ 

#define CRC_DATA_SEED                   1        /*!< 写入CRC数据寄存器的值为种子值 */  

#define CRC_DATA_DATA                   0        /*!< 写入CRC数据寄存器的值为数据值 */ 

#define CRC_READ_COMPLETE               1        /*!< 反转或补充CRC数据寄存器的读取值 */ 

#define CRC_READ_NONE                   0        /*!< 读取数据寄存器时不执行异或运算*/ 

#define CRC_READ_TRANSPOSE_NONE         0        /*!< 读取数据寄存器的值无转置 */ 

#define CRC_READ_TRANSPOSE_BIT          1        /*!< 读取数据寄存器的值，字节中的位转置，字不转置*/

#define CRC_READ_TRANSPOSE_ALL          2        /*!< 读取数据寄存器的值，字节中的位和字节均转置 */

#define CRC_READ_TRANSPOSE_BYTE         3        /*!< 读取数据寄存器的值，仅字节转置，字节中的位不转置 */

#define CRC_WRITE_TRANSPOSE_NONE        0        /*!< 写数据时无转置 */

#define CRC_WRITE_TRANSPOSE_BIT         1        /*!< 写数据时，字节中的位转置，字节不转置 */ 

#define CRC_WRITE_TRANSPOSE_ALL         2        /*!< 写数据时，字节中的位和字节均转置 */

#define CRC_WRITE_TRANSPOSE_BYTE        3        /*!< 写数据时，仅字节转置，字节中的位不转置 */

CRC 配置结构体类型

复制

typedef struct

{          

    uint8_t bWidth                  : 1;    /*!< 1: 32位CRC协议  0: 16位CRC协议 */

    uint8_t bDataType               : 1;    /*!< 1: 写入种子值 , 0: 写入数据 */

    uint8_t bFinalXOR               : 1;    /*!< 1: 读数据是反转或补充 , 0: 读数据时不执行异或*/

    uint8_t bRESERVED               : 1;    /*!< 保留位 */  

    uint8_t bTransposeReadType      : 2;    /*!< 读取数据时的转置类型, 参阅参考手册 */

    uint8_t bTransposeWriteType     : 2;    /*!< 写数据时的转置类型, 参阅参考手册 */      

    uint32_t u32PolyData               ;    /*!< 32位或16位多项式*/           

} CRC_ConfigType, *CRC_ConfigPtr  ; 

硬件CRC

CRC至今没有搞懂。