bbbch.c

基于TI公司的CC1020芯片的无线通讯程序,程序的MCU是TI公司的MSP430系列。

#include "bch.h"
#include "msp430x14x.h"

#define   HEADLEN   3
char             recd[31], data[21], bb[11];
const char      p[6]={1,0,1,0,0,1};		/* irreducible polynomial */
const signed char   alpha_to[32]={ 
      1,2,4,8,16,5,10,20, 13,26,17,7,14,28,29,31,
      27,19,3,6,12,24,21,15,30,25,23,11,22,9,18,0
      };
const signed char   index_of[32]={
      -1,0 ,1 ,18,2 ,5 ,19,11,3 ,29,6 ,27,20,8 ,12,23,
      4 ,10,30,17,7 ,22,28,26,21,25,9 ,16,13,14,24,15
      };
const signed char  g[11]={
      1,0,0,1,  0,1,1,0,  1,1,1
      };
 char CRCHighByte=0;
 char CRCLowByte=0;
 char CRCResult=0; 
char  rerr=0;

void encode_bch()
{
	register signed  char    i, j;
	signed char    feedback;
	for (i = 0; i < 10; i++)
		bb[i] = 0;
	for (i = 20; i >= 0; i--) {
		feedback = data[i] ^ bb[9];
		if (feedback != 0) {
			for (j = 9; j > 0; j--)
				if (g[j] != 0)
					bb[j] = bb[j - 1] ^ feedback;
				else
					bb[j] = bb[j - 1];
			bb[0] = feedback;
		} else {
			for (j = 9; j > 0; j--)
				bb[j] = bb[j - 1];
			bb[0] = 0;
		       }
	}
}

void decode_bch()
{
	register signed char   ii, jj;

	signed char             elp[3], s[5], s3, q;
	signed char            count = 0, syn_error = 0;
	signed char              loc[3],  reg[3];
	signed char  				aux;
	for (ii = 1; ii <= 4; ii++) {
		s[ii] = 0;
		for (jj = 0; jj < 31; jj++)
			if (recd[jj] != 0)
				s[ii] ^= alpha_to[(ii * jj) % 31];
		if (s[ii] != 0)
			syn_error = 1;	/* set flag if non-zero syndrome */
		s[ii] = index_of[s[ii]];
	};
	if (syn_error) {	/* If there are errors, try to correct them */
		if (s[1] != -1) {
			s3 = (s[1] * 3) % 31;
			if ( s[3] == s3 )  /* Was it a single error ? */
				{
				recd[s[1]] ^= 1;		/* Yes: Correct it */
				}
			else {				/* Assume two errors occurred and solve
								 * for the coefficients of sigma(x), the
								 * error locator polynomail
								 */
                if (s[3] != -1)
                  aux = alpha_to[s3] ^ alpha_to[s[3]];
                else
                  aux = alpha_to[s3];
				elp[0] = 0;
				elp[1] = (s[2] - index_of[aux] ) % 31;
				elp[2] = (s[1] - index_of[aux] ) % 31;
				/* find roots of the error location polynomial */
				for (ii = 1; ii <= 2; ii++)
					reg[ii] = elp[ii];
				count = 0;
				for (ii = 1; ii <= 31; ii++) { /* Chien search */
					q = 1;
					for (jj = 1; jj <= 2; jj++)
						if (reg[jj] != -1) {
							reg[jj] = (reg[jj] + jj) % 31;
							q ^= alpha_to[reg[jj]];
						}
					if (!q) {	/* store error location number indices */
						loc[count] = ii % 31;
						count++;
					}
				}
				if (count == 2)	
				/* no. roots = degree of elp hence 2 errors */
				{	for (ii = 0; ii < 2; ii++)
						recd[loc[ii]] ^= 1;
				        rerr &= ~0x02;
				}		
            			else	/* Cannot solve: Error detection */		
                                     rerr|=0x02; //-----------------------------------
				}
			}
	             else if (s[2] != -1) /* Error detection */
                                     rerr|=0x02;
	}
}

char
bch_to_send(char *ptrIn,char leng,char *ptrans)//。。。leng=len+1，可将len+1部分去除，这样可以适用于50，20等情况
{                      //ptrin是去除了第一个字节firstbyte的指针，
	char ti,tj,tk=0,ri=0,rk=0;
	char *pdata;
	char temp,full=0,r31=0;
	char much; //实际需要发送的字节数
	char many=0; //是否需要添加额外的字节
	char  i,rkcnt ;
	//int len;  //-------------------------------------------------------

	//len=(int)*ptrIn;
	//len=(int)(*(ptrIn+6))+6+2;      //**6 is FF, 2 is CRC,如果是50格式的，6和2去掉//----------------------------- 
	if( (leng*8)%21==0) {
		much=leng;
    		many=0; 
    	} else {
		much =21-((leng)*8)%21;   //rk=((len+1)*8 ) /21 +1
    		many=1;    
 		if (much%8==0)  much=much/8+leng;    //rk=((len+1)*8 ) /21 +1
		else much=much/8+1+leng;
	}

	rkcnt=((char)((leng)*8) ) /21 +many-1;
 	///注意，可能会溢出，所以后期要把len的数据类型改进
   	for(ti=0;ti<much;ti++)  { //len+1是发送的字节数,最多补3个字节
		if(rk==rkcnt) {
			if (ti>=leng)   //notice...
				temp=0;
			else
				temp=*(pdata+ti);   
		} else {
			temp=*(pdata+ti);
		}
		
		for(tj=0; tj<8; tj++) { 
			//横变竖
			//   temp=*(pdata+ti);
			if(rk==rkcnt) {
				if (ti>=leng)
					temp=0;
				else
					temp=*(pdata+ti);   
			} else temp=*(pdata+ti);

			temp=temp << tj;      //notice
			if(temp<128)       // 1 or 0
				data[tk]=0;
			else  
				data[tk]=1;  //save to data[]
			tk++;
			if(tk==21) {
				full=1;
				tk=0;      
                 	}
             
			//encode data//
			if(full==1) {
				full=0;
				encode_bch();			/* encode data */ 
				for (i = 0; i < 10; i++)
					recd[i] = bb[i];	/* first (length-k) bits are redundancy */
				for (i = 0; i < 21; i++)
					recd[i + 10] = data[i];	/* last k bits are data */        
				for(ri=0;ri<31;ri++)
					recd[ri]=recd[ri]&1;
				//
				r31=0;
				//
				//         for(ri=0;ri<31;ri++)
				//              r31 ^=recd[ri];  //偶校验          
				*(ptrans+4*rk)=recd[0]*128+recd[1]*64+recd[2]*32+recd[3]*16+recd[4]*8+recd[5]*4+recd[6]*2+recd[7];
				*(ptrans+4*rk+1)=recd[8]*128+recd[9]*64+recd[10]*32+recd[11]*16+recd[12]*8+recd[13]*4+recd[14]*2+recd[15];
				*(ptrans+4*rk+2)=recd[16]*128+recd[17]*64+recd[18]*32+recd[19]*16+recd[20]*8+recd[21]*4+recd[22]*2+recd[23];
				*(ptrans+4*rk+3)=recd[24]*128+recd[25]*64+recd[26]*32+recd[27]*16+recd[28]*8+recd[29]*4+recd[30]*2+r31;
				rk++;                    
			}  
		}
		//循环完一个字节
	} 
	return 4*rk;    
}


/*****************fuction of recv of bch **********************
** prev: 输入的开始地址   lenin：输入的长度*******************
** pout： 输出的开始指针      ********************************
**返回值lenout： 解码的所有字节，包括后面添加0的字节数      ***
**所以有用的字节长度要自己通过解码后的字节里面的数据推算， ****
**不能用 lenout来推算; more 0,1,2,3 bytes*********************
************************************************************8***/
//接收
char 
testbit(char temp,char n)            //  this is : (temp>> n) & 1  
{
   char temp2=temp >> n;
   return(temp2 & 1);
}


char
recv_of_bch(char *precv,char lenin,char *pout)
{
char ti,tj,tk=0,ri=0,rtemp=1;
char *pdata,* pdt;
char temp,r31=0;
char z;
char lenout=0;

pdata=precv;                          //precv是接收到的流,pdata用于变动的指针
pdt=pout;                            //pout是要用于输出的流，pdt是变动的指针


           //
         *pdt=0;
           //  
   for(ti=0;ti<lenin/4;ti++)              //每一次做一个rk, that is, handle 4 bytes.
   {
 //       for(tj=0;tj<31;tj++)
  //      { //横变竖
  //        temp=*pdata+tj/8;    
  //        recd[tj]=testbit(temp,7-tj+ 8*((char)(tj/8)) );
  //       } 
      for(tj=0;tj<8;tj++)               //bit 0~8
        { //横变竖
          temp=*pdata;    
          recd[tj]=(temp>>(7-tj)) & 1;   //testbit  should be rewrited to a equation.
         } 
         for(tj=8;tj<16;tj++)
        { //横变竖
          temp=*(pdata+1);    
          recd[tj]=(temp>>(7-tj+8)) & 1;
         }
          for(tj=16;tj<24;tj++)
        { //横变竖
          temp=*(pdata+2);    
          recd[tj]=(temp>>(7-tj+16)) & 1;
         }
          for(tj=24;tj<31;tj++)          //bit 0~31
        { //横变竖
          temp=*(pdata+3);    
          recd[tj]=(temp>>(7-tj+24)) & 1;
         }
         //没有recd[31],因而丢弃最后一位bit0;
         pdata+=4;
 
         decode_bch();
         //得到了dati[i];  竖变横 
         tk=0;                        //for whar?
         for(z=0;z<21;z++)
           data[z]=recd[10+z];
         
         for (;;)
         {        temp=*pdt;  
                  rtemp=1;
                  for(z=0;z<7-ri;z++)
                     rtemp*=2;
                  if(data[tk]==1)
                  {
                    *pdt+=rtemp;
                  }
                  if (ri==7)
                  {    ri=0;
                     pdt+=1;
                     lenout++;
                     *pdt=0;
                  }
                  else
                      ri++;
                   tk++;
                               //把一个data[] 转换成out[]中一个字节的 其中一位
                  if(tk==21)
                  { // if(ri==0)
                    // pdt+=1;
                     break;
                  }               
          }                  //上面的程序就是把data给凑进去     
     }
return lenout;
} 
void
cross16(char *tuple,char count,char*out)
{  char i,j,z,k,temp,tc;
  for(i=0;i<count;i++)
     *(out+i)=*(tuple+i);


  i=0,j=0,z=0,k=0,temp=0,tc=0;
 // for(i=0;i<count;i++)
//      *(out+i)=0;
  *out=0;
  i=0;
  for (j=0;j<8;)
  {     
        for (k=0;k<8;k++)
        {
             (*(out+z))+=((*(tuple+i) >> (7-j)) & 1) <<(7-k);    //i,7-j
            i+=2;
            if(i==count)
            {
              j++;
              i=0;
            if(j==8)
                 break;
            }     
        }
        z++;
        *(out+z)=0;
        
  }
  i=0;
    for (j=0;j<8;)
  {     
        for (k=0;k<8;k++)
        {
              (*(out+z))+=((*(tuple+i+1)>>(7-j)) & 1) <<(7-k);
            i+=2;
            if(i==count)
            {
              j++;
              i=0;
            if(j==8)
                 break;
            }     
        }
        z++;   *(out+z)=0;
             
  }    
 
}

/***fuction of anti-cross16    ***********************************
****income:接收缓冲区的地址，以及要解交织的长度*******************
****outcome:一位数组，长度不变，存在trans[]中  *******************
****这个代码根据cross16现场改编的，改动很小***********************
*******************************************************/
///////
void
anticross16(char *rin,char rlen,char *rbuf)
{   char i,j,z,k,temp,tc;
for(i=0;i<rlen;i++)
      *(rbuf+i)=*(rin+i);

  j=0,z=0,k=0,temp=0,tc=0;
  for(i=0;i<rlen;i++)
      *(rbuf+i)=0;
     i=0;
  for (j=0;j<8;)
  {     
        for (k=0;k<8;k++)
        {
          //   (*(out+z))+=((tuple[i] >> (7-j)) & 1) <<(7-k);    //i,7-j
      *(rbuf+i) +=((*(rin+z) >> (7-k)) & 1) <<(7-j);            //i,7-j
            i+=2;
            if(i==rlen)
            {
              j++;
             
              
              i=0;
            if(j==8)
                 break;
            }     
        }
        z++;      
  }
  i=0;
    for (j=0;j<8;)
  {     
        for (k=0;k<8;k++)
        {
             *(rbuf+i+1) +=((*(rin+z) >> (7-k)) & 1) <<(7-j);    //i,7-j
            i+=2;
            if(i==rlen)
            {
              j++;
                            *(rbuf+i+1)=0;

              i=0;
              if(j==8)
                 break;
            }     
        }
        z++;
  }
  
}