uart.c

本文档用于描述一体化组合模块485监控板监控对象

			 {
			   InvertTabDesc.Value[i]=*(index_u8+3*i+4);	
			   //m = *(index_u8+3*i+5);
			   //m += (U16)(*(index_u8+3*i+6) << 8);
                           m =*(U16 *)(index_u8+3*i+5);
			   InvertTabDesc.Level[i]=m;
			  }
                      ///////////////////////////////////////
                      i = 0;
		      while(i<(InvertTabDesc.Len-1))
		      {
			  m=InvertTabDesc.Level[i]+InvertTabDesc.Level[i+1];
			  InvertTabDesc.Limit[i]=(m/2);
			  ++i;
		       }
		       InvertTabDesc.Limit[InvertTabDesc.Len-1]=InvertTabDesc.Level[InvertTabDesc.Len-1]+6;
                      ///////////////////////////////////////
		      Add_CRC((U8 *)&InvertTabDesc,(sizeof(TabStruct)-2));		
		      k = sizeof(TabStruct);
		      j = 0;
		      while(k)
			{
			  i=Seek_EEPROM();
		          EepromBuffDesc[i].MemAddr=I2C_INVERT_MEMORY + (j * I2C_PAGE_LEN);
			  EepromBuffDesc[i].BuffAddr=(U16)&InvertTabDesc + (j * I2C_PAGE_LEN);
			  if (k <= I2C_PAGE_LEN)
			    {
			     EepromBuffDesc[i].Len=k;
			     k = 0;
			    }
			  else
			    {
			     EepromBuffDesc[i].Len= I2C_PAGE_LEN;
			     k -= I2C_PAGE_LEN;
			    }
			    ++j;
			 }
                      }

                      if(UARTContext.RxData[11]==0x02)/*查询*/
		      {
                      memcpy(TxData_pt,Commands.Index[n],3);
                      TxData_pt = TxData_pt + 3;
		      *TxData_pt = InvertTabDesc.Len;
		      TxData_pt++;
		      for(i=0;i<InvertTabDesc.Len;i++)
			{
			  *TxData_pt=InvertTabDesc.Value[i];
			  TxData_pt++;
			  *TxData_pt=(U8)InvertTabDesc.Level[i];
			  TxData_pt++;
			  *TxData_pt=(U8)(InvertTabDesc.Level[i] >> 8);
			  TxData_pt++;
			}	
                      memset(TxData_pt,0,(TAB_SIZE-i)*3);
		      TxData_pt += (TAB_SIZE-i)*3;
		      }
                      break;

              case 0x04A6:/*低噪放输出功率表*/
                   if(UARTContext.RxData[11]==0x03)/*设置*/
                     {
                      LnaTabDesc.Len=*(index_u8+3);
		      memcpy(TxData_pt,Commands.Index[n],124);
                      TxData_pt = TxData_pt + 124;
                      if(LnaTabDesc.Len>TAB_SIZE)
			    LnaTabDesc.Len=TAB_SIZE;
		      for(i=0;i<LnaTabDesc.Len;i++)
			 {
			  LnaTabDesc.Value[i]=*(index_u8+3*i+4);
			  //m = *(index_u8+3*i+5);
		          //m += (U16)(*(index_u8+3*i+6) << 8);
                          m =*(U16 *)(index_u8+3*i+5);
			  LnaTabDesc.Level[i]=m;
			 }
                      ///////////////////////////////////////////
                      i = 0;
		      while(i<(LnaTabDesc.Len-1))
			{
				m=LnaTabDesc.Level[i]+LnaTabDesc.Level[i+1];
				LnaTabDesc.Limit[i]=(m/2);
				++i;
			}
		      LnaTabDesc.Limit[LnaTabDesc.Len-1]=LnaTabDesc.Level[LnaTabDesc.Len-1]+20;
                     /////////////////////////////////////////////
		      Add_CRC((U8 *)&LnaTabDesc,(sizeof(TabStruct)-2));	
		      j = 0;
		      k = sizeof(TabStruct);
		      while(k)
			{
			  i=Seek_EEPROM();
			  EepromBuffDesc[i].MemAddr=I2C_LNA_MEMORY + (j * I2C_PAGE_LEN);
			  EepromBuffDesc[i].BuffAddr=(U16)&LnaTabDesc + (j * I2C_PAGE_LEN);
			  if (k <= I2C_PAGE_LEN)
			    {
			     EepromBuffDesc[i].Len=k;
			     k = 0;
			    }
			   else
			    {
			     EepromBuffDesc[i].Len= I2C_PAGE_LEN;
			     k -= I2C_PAGE_LEN;
			    }
			    ++j;
			 }

                     }
		    if(UARTContext.RxData[11]==0x02)/*查询*/
		      {
                       memcpy(TxData_pt,Commands.Index[n],3);
                       TxData_pt = TxData_pt + 3;
		       *TxData_pt = LnaTabDesc.Len;
		       TxData_pt++;
                       for(i=0;i<LnaTabDesc.Len;i++)
			 {
		           *TxData_pt=LnaTabDesc.Value[i];
			   TxData_pt++;
			   *TxData_pt=(U8)LnaTabDesc.Level[i];
			   TxData_pt++;
			   *TxData_pt=(U8)(LnaTabDesc.Level[i] >> 8);
			   TxData_pt++;
			 }	
                        memset(TxData_pt,0,(TAB_SIZE-i)*3);
		        TxData_pt += (TAB_SIZE-i)*3;
		      }
                      break;
              default:
                      break;
	      }
       }

  if(propertydesc_change > 0)
    {
      Add_CRC((U8 *)&PropertyDesc,(sizeof(PropertyStruct)-2));
      k = sizeof(PropertyStruct);
      j = 0;	
      while(k)
	{
	  i=Seek_EEPROM();
	  EepromBuffDesc[i].MemAddr=I2C_PROPERTY_MEMORY+(j * I2C_PAGE_LEN);
	  EepromBuffDesc[i].BuffAddr=(U16)&PropertyDesc + (j * I2C_PAGE_LEN);
	  if(k <= I2C_PAGE_LEN)
	    {
	      EepromBuffDesc[i].Len=k;
	      k = 0;
	    }
	   else
	    {
	     EepromBuffDesc[i].Len=I2C_PAGE_LEN;
	     k-= I2C_PAGE_LEN;
	    }
	  ++j;
	}
    }

  Add_CRC(UARTContext.TxData,(U8)(TxData_pt-UARTContext.TxData) );
  TxData_pt += 2;/*ADD CRC DATA*/
  Code_data( (U8)(TxData_pt-UARTContext.TxData) );
  UART_Send();
}


U16 CRC_generator(U8 *CrcArray,U8 length)
{
	U8 da;	
	U16 CRC_code=0;
	while(length--!=0)
	{
		da=(U8) (CRC_code/256); // 以8位二进制数的形式暂存CRC的高8位
		CRC_code<<=8; // 左移8位，相当于CRC的低8位乘以
		CRC_code^=CrcTab[da^*CrcArray]; // 高8位和当前字节相加后再查表求CRC ，再加上以前的CRC
		CrcArray++;
	}

	return CRC_code;
}

U8 Verify_CRC(U8 *CrcArray,U8 length)
{
	U16 CrcCode;

	CrcCode = CRC_generator(CrcArray, length-2  /* take off old crc */ );

	if( *(CrcArray + length - 1)
		!=
		(U8)(CrcCode >> 8) )
		return FALSE;

	if( *(CrcArray + length - 2)
		!=
		(U8)(CrcCode) )
		return FALSE;

	return TRUE;
}

void Add_CRC(U8 *CrcArray,U8 length)
{
	U16 CrcCode;

	CrcCode = CRC_generator(CrcArray, length);

	*(CrcArray + length) = (U8)CrcCode;	          //CRC Low Word
	*(CrcArray + length + 1) = (U8)(CrcCode >> 8);//CRC High Word

	*(CrcArray + length + 2) = 0;					  //Last Byte
}


U8 Decode_data()
{
	U8 *dest;
	U8 *src;
	
	dest = UARTContext.RxData;
	src = UARTContext.RxBuff;

	++src;		//Skip head (PACKAGE_BEGIN)

	// Check length
//	if(UARTContext.RxLen < UART_LENGTH_LIMIT)
//		return LENGTH_ERROR;

	// Check address
//	if( ( *(src) != PropertyDesc.FunAddr )
//	 || ( *(src+1) != PropertyDesc.ModuleAddr ) )
//		return ADDRESS_ERROR;
				

	while( PACKAGE_END != *src )
	{
		if( *src == CONVERT_CHAR )
		{ //Parse Convert char
			++src;	//Skip convert char
			if(*src == CONSTANT_5E)
			  {
                         *dest++ = CONVERT_CHAR;	
			  }
			 else
			  {
                         *dest++ = PACKAGE_END;
			  }
                        ++src;	
		}				
		else
		{
			*dest++ = *src++;	// Direct copy	
		}
	}
       UARTContext.RxLen = (U8)(dest - UARTContext.RxData);
	// Check CRC
	if( !Verify_CRC(UARTContext.RxData,dest-UARTContext.RxData /*clear head and tail*/) )
		return CRC_ERROR;	
		
	return INERRANCY;
}

void Code_data(U8 length)
{
	U8 *dest;
	U8 *src;
	
	dest = UARTContext.TxBuff;
	src = UARTContext.TxData;

	*dest++ = PACKAGE_BEGIN;

	while( 0 != length-- )
	{
		if(	( *src == PACKAGE_BEGIN)
		    ||	( *src == CONVERT_CHAR) )
		{// Converting char
			*dest++=CONVERT_CHAR;

			//*dest++ = (U8)(~(*src++));	// Rolling then copy

			/*
			if(*src == CONVERT_CHAR)
			  {
                         *dest++ = CONSTANT_5E;	
			  }
			 else
			  {
                         *dest++ = CONSTANT_7E;
			  }
			 ++src;	//Skip convert char
			 */

			 *dest++ = (U8)(*src++)-1;
		}
		else
		{
			*dest++ = *src++;	// Direct copy
		}
	}

	*dest++ = PACKAGE_END;

	UARTContext.TxLen = dest - UARTContext.TxBuff; //Calculate length
}
void Command_distill(void)
{
 U8 i=0;
 U8 counter = COMMAND_START;

       while( (UARTContext.RxLen-2) > counter)
 	{
        Commands.Index[i] = UARTContext.RxData+counter;
        counter += *(UARTContext.RxData+counter);
	 i++;
       }
       Commands.Counter = i;


}