C语言CRC-8 MAXIM格式校验函数

CRC校验基于前处理和后处理的不同，由不同的公司推出了一些不同格式的版本。这里介绍CRC-8 MAXIM格式的校验函数。

CRC-8 MAXIM格式特征

标准CRC-8的校验函数参考： C语言标准CRC-8校验函数
CRC-8 MAXIM格式有如下的不同：

输入数据的每个字节做反转，这里的反转不是指每个字节里的位反（取~），而是每个字节里的位序反。也就是0x01需要反转为0x80。这里的反转是对每个字节单独进行反转，再形成新数组，不是对整个数组的所有位一起反转，所以0x01 0x02的反转是0x80 0x40而不是0x40 0x80。
CRC计算完成得到的余数，还要做一次反转，仍然是位序反转，作为最后的输出结果
最后的结果要异或0x00,但任何字节数异或0x00等于其自身，故此条可省略。
计算的多项式为X8+X5+X4+1, 不同于标准CRC-8采用的X8+X2+X1+1

CRC-8 MAXIM校验函数

由上面的介绍可知，从标准CRC校验函数，调整三个方面的设计，就可形成CRC-8 MAXIM校验函数。

CRC-8 MAXIM校验函数如下：

#include <stdio.h>
#include <stdlib.h>

uint8_t PY_CRC_8_MAXIM(uint8_t *di, uint32_t len)
{   //Written by Pegasus Yu 2022/09/07
	uint16_t crc_poly = 0x0131; //X^8+X^5+X^4+1 total 9 effective bits. Computed total data shall be compensated 8-bit '0' before CRC computing.
	uint8_t *datain;
	uint64_t cdata = 0; //Computed total data
	uint16_t data_t = 0; //Process data of CRC computing

	uint16_t index_t = 63;  ///bit shifting index for initial '1' searching
	uint16_t index = 63;    //bit shifting index for CRC computing
	uint8_t rec = 0; //bit number needed to be compensated for next CRC computing

	uint32_t cn=(len+1)/7;
	uint32_t cr=(len+1)%7;

	uint32_t j;

	datain = malloc(len+1);
	for(j=0;j<len;j++)  //bit sequence inversion for input bytes
	{
		datain[j]=0;
		for(uint32_t m=0; m<8; m++)
		{
			datain[j] <<= 1;
			datain[j] |= ((di[j]>>m)&0x01);
		}
	}
	    datain[len]=0; //Compensate 8-bit '0' for input data

     if(len<=7)
     {
    	 for(j=0;j<=len;j++)
    	 {
    		 cdata = (cdata<<8);
    		 cdata = cdata|datain[j];
    	 }
    	 cn = 1;
     }
     else
     {
    	 if(cr==0)
    	 {
    		 cr=7;
    	 }
    	 else
    	 {
    		 cn++;
    	 }

    	 for(j=0;j<cr;j++)
    	 {
    		 cdata = (cdata<<8);
    		 cdata = cdata|datain[j];
    	 }
     }

     do
     {
 		cn--;

 		while(index_t>0)
 		{
 			if( (cdata>>index_t)&1 )
 			{
 				index = index_t;
 				index_t = 0;

 				data_t |= (cdata>>(index-8));
 				{
 					data_t = data_t ^ crc_poly;
 				}

 	            while((index!=0x5555)&&(index!=0xaaaa))
 	            {
 	            	/*
 	    			if ((data_t>>7)&1) rec = 1;
 	    			else if ((data_t>>6)&1) rec = 2;
 	    			else if ((data_t>>5)&1) rec = 3;
 	    			else if ((data_t>>4)&1) rec = 4;
 	    			else if ((data_t>>3)&1) rec = 5;
 	    			else if ((data_t>>2)&1) rec = 6;
 	    			else if ((data_t>>1)&1) rec = 7;
 	    			else if ((data_t>>0)&1) rec = 8;
 	    			else rec = 9; */

	 	    		for(uint8_t n=1;n<9;n++)
	 	    		{
	 	    			if ((data_t>>(8-n))&1) {rec = n;break;}
	 	    			if (n==8) rec=9;
	 	    		}

 	    			if((index-8)<rec)
 	    			{
 	    				data_t = data_t<<(index-8);
 	    				data_t |=  (uint16_t)((cdata<<(64-(index-8)))>>(64-(index-8)));
 	    				index = 0x5555;
 	    			}
 	    			else
 	    			{
 	        			for(uint8_t i=1;i<=rec;i++)
 	        			{
 	        				data_t = (data_t<<1)|((cdata>>(index-8-i))&1) ;
 	        			}

 	        			if(rec!= 9)
 	        			{
 	        				data_t = data_t ^ crc_poly;
 	        				index -= rec;
 	        			}
 	        			else
 	        			{
 	        				data_t = 0;
 	        				index_t = index-8-1;
 	        				index = 0xaaaa;

 	        			}

 	    			}

 	            }
 				if(index==0x5555) break;
 			}
 			else
 			{
 				index_t--;
 				if(index_t<8) break;
 			}
         }

 		if(cn>0)
 		{
  			cdata = data_t&0x00ff;

 			for(uint8_t k=0;k<7;k++)
 			{
 	    		 cdata = (cdata<<8);
 	    		 cdata = cdata|datain[j++];

 			}

 	    	data_t = 0;
 	 		index_t = 63;  ///bit shifting index for initial '1' searching
 	 		index = 63;    //bit shifting index for CRC computing
 	 		rec = 0; //bit number needed to be compensated for next CRC computing
 		}

     }
     while(cn>0);

     //bit sequence inversion for output byte
     datain[0] = data_t;
     data_t = 0;
	 for(uint32_t m=0; m<8; m++)
	{
		data_t <<= 1;
		data_t |= ((datain[0]>>m)&0x01);
	}

     free(datain);
     return data_t;

}