DDB/source/bsp/bsp_oid.c

#include   "bsp_oid.h"
#include    "intrins.h"
#include "../msp/uart0.h"
#include     <stdio.h>
#include "../ctask/task.h"
#include "../ctask/tick.h"


/******************************************************************************************************
															           变量定义
*******************************************************************************************************/
AppDevice eAppDevice = ePointRead_2000A;
///volatile uint32_t RecvData[3];
Ts_OID_ ts_oid;

uint8_t  TransCmd[7];
///#define MAIN_Fosc 11059260L
#if 0
#define MAIN_Fosc (12459260L/4)
#define D_DELAY_10US	10
#define D_DELAY_ROD_80US	80


#else
#define MAIN_Fosc (12459260L/2)
#define D_DELAY_10US	20
#define D_DELAY_ROD_80US	160


#endif


//========================================================================
// 函数: void delay_ms(uint8_t ms)
// 描述: 延时函数。
// 参数: ms,要延时的ms数, 这里只支持1~255ms. 自动适应主时钟.
// 返回: none.
// 版本: VER1.0
// 日期: 2021-3-9
// 备注: 
//========================================================================
void delay_ms(uint8_t ms)
{
     uint16_t i;
     do{
          i = MAIN_Fosc / 10000L;
          while(--i);   //10T per loop
     }while(--ms);
}

void delay_us(uint8_t us)
{
     uint16_t i;
     do{
         // i = MAIN_Fosc / 10000000L;
      //    i = 1;///5  10  150u   1---50us
      ///    while(--i);   //10T per loop
     }while(--us);
}

/******************************************************************************************************
Function:
Input:
Output:
*******************************************************************************************************/
void L0_oid_SendCmd(uint8_t Cmd)
{
	uint8_t i;
	LD_Oid_SDIO_OUT();
	LD_Oid_SCK_HIGH();
	LD_Oid_SDIO_HIGH();              // Write control bit	
	delay_us(D_DELAY_10US);
	LD_Oid_SCK_LOW();
	delay_us(D_DELAY_10US);

	for(i=0;i<8;i++)
	{
		LD_Oid_SCK_HIGH();
		if(Cmd & 0x80)
		{
			LD_Oid_SDIO_HIGH();
		}
		else
		{
			LD_Oid_SDIO_LOW();
		}
		delay_us(D_DELAY_10US);
		LD_Oid_SCK_LOW();

		#if 0
		if(i == 7)
		{
			LD_Oid_SDIO_IN();
		}
		#endif
		delay_us(D_DELAY_10US);
		Cmd <<= 1;
	}
	delay_us(D_DELAY_ROD_80US);
	LD_Oid_SDIO_IN();
}

uint16_t L0_oid_RecvAck16(void)
{
	uint8_t i;
	uint16_t AckValue;
	AckValue = 0;	
///
LD_Oid_SDIO_OUT();
	delay_us(D_DELAY_10US);
	LD_Oid_SCK_HIGH();
	LD_Oid_SDIO_LOW();
	delay_us(D_DELAY_10US);
	LD_Oid_SCK_LOW();
	delay_us(D_DELAY_10US);
	
	for(i = 0; i < 16; i++)
	{
		LD_Oid_SCK_HIGH();
		LD_Oid_SDIO_IN()
		delay_us(D_DELAY_10US);
		LD_Oid_SCK_LOW();
		if(OID_DET)
		{
			AckValue +=1;
		}
		
		if(i < 15)
		{
			AckValue <<= 1;
		}
		
		delay_us(D_DELAY_10US);
	}
	delay_us(D_DELAY_ROD_80US);
	
	return AckValue;
}


void L0_oid_Recv64(void)
{
	uint8_t i;
	Lc_memset8bits(ts_oid.rec.d, 0, 8); 
	LD_Oid_SDIO_OUT();
	delay_us(D_DELAY_10US);
	LD_Oid_SCK_HIGH();
	LD_Oid_SDIO_LOW();
	  
	delay_us(D_DELAY_10US);
	LD_Oid_SCK_LOW(); 	
	
	delay_us(D_DELAY_10US);
	LD_Oid_SDIO_IN()
	
	for(i = 0; i < 64; i++)
	{
		LD_Oid_SCK_HIGH();
		delay_us(D_DELAY_10US);
		LD_Oid_SCK_LOW();
		

		#if 0
		if(OID_DET)
		{
			if(i < 32)
			{
				RecvData[0] += 1;
			}
			if(i>=32 && i<64)
			{
				RecvData[1] += 1;
			}
		
		}

		if(i < 31)
		{
			RecvData[0] <<= 1;
		}
		if( i >31 && i < 63)
		{
			RecvData[1] <<= 1;
		}
		#endif

		///#else

		ts_oid.rec.d[i/8] <<= 1;

		if(OID_DET)
		{
			ts_oid.rec.d[i/8] |= 1;
			//	RecvData[1] += 1;
		}
		else
		{
			ts_oid.rec.d[i/8] &= 0xfe;
		}
		//	RecvData[1] <<= 1;



		delay_us(D_DELAY_10US);
	}
	
	
	ts_oid.time = D_sys_now;
	delay_us(D_DELAY_ROD_80US);
	
	return;
}	

uint8_t L1_oid_TransCmd(uint8_t Cmd)
{
	uint8_t TxCmd;///,det_busy;
	uint32_t RxAckCnt = 0;
	
//	L0_uart0_sendstr("\r\n	w cmd="); 
///	L0_uart0_uchex(Cmd);
//
	while(!OID_DET)
	{
		L0_oid_Recv64();
		L1_print_rcv("\r\n busy: RD=");
	}
	TxCmd = Cmd;
	L0_oid_SendCmd(TxCmd);
	LD_Oid_SCK_LOW();
	delay_us(10);
	#define D_oid_waitrcv_delay	100000
	while(OID_DET)
	{
	///	L1_oid_RecvOptData();
		RxAckCnt ++;
		if(RxAckCnt > D_oid_waitrcv_delay)
		{
		
			L0_uart0_sendstr("\r\nno rec"); 
			L0_uart0_uchex(Cmd);
			break;
		}
	}

	if(RxAckCnt <= D_oid_waitrcv_delay)
	{
		TxCmd = (uint8_t)L0_oid_RecvAck16();
		TxCmd -= 1;
		if(TxCmd == Cmd)
		{
		
			L0_uart0_sendstr("\r\nCmd="); 
			L0_uart0_uchex(Cmd);L0_uart0_uc('-');
			L0_uart0_uchex(TxCmd);
			return 1;
		}
	}
}

uint32_t L1_oidReadRegister (uint16_t Data1)
{
	 uint8_t i,Ret;
	 uint32_t uxReturn;
	
	 TransCmd[0] = 0x74;
	 TransCmd[1] = 3;
	 TransCmd[2] = Data1 >> 8;
	 TransCmd[3] = Data1 & 0x00FF;
	 TransCmd[4] = (TransCmd[1] + TransCmd[2] + TransCmd[3]) & 0xFF;
		
	 for(i=0;i<5;i++)
	 {
			Ret = L1_oid_TransCmd(TransCmd[i]);
			if(Ret == 0)
			{
				return 0x5FFFFFFF;
			}
	 }
	 
	 i = 0;
	 while(1)
	 {
		 if(!OID_DET)
		 {
			 L0_oid_Recv64();

			/// uxReturn = RecvData[1];
			 uxReturn = ts_oid.rec.d32[1];
			 uxReturn &= 0xFFFF;
			 return uxReturn;
		 }

		 delay_us(100);
		 i += 1;
		 if(i >= 20)         // check 100ms
		 {
			 return 0x2FFFFFFF;
		 }
	 }
}

/******************************************************************************************************
Function:
Input:
Output:
*******************************************************************************************************/
uint8_t Write_Register(uint16_t Data1,uint16_t Data2)
{    
	uint8_t Ret,i;
	uint16_t j;
	Ret = 1;
	
	TransCmd[0] = 0X73;
	TransCmd[1] = 0x05;
	j = Data1>>8;
	TransCmd[2] = (uint8_t)j;
	j = Data1;
	TransCmd[3] = (uint8_t)j;
	j = Data2>>8;
	TransCmd[4] = (uint8_t)j;
	j = Data2;
	TransCmd[5] = (uint8_t)j;
	TransCmd[6] = (TransCmd[1] + TransCmd[2] + TransCmd[3] + TransCmd[4] + TransCmd[5]);
         
	for(i=0;i<7;i++)
	{
		Ret = L1_oid_TransCmd(TransCmd[i]);
		if(Ret == 0)
		{
			break;
		}
	}
	return Ret;
}

void L1_print_rcv(char *str)
{
	L0_uart0_sendstr(str);
	/********
//	Lc_delay_ms(1);
	L0_uart0_ulhex(RecvData[0]);
//	Lc_delay_ms(1);
	L0_uart0_uc(0x09);
	L0_uart0_ulhex(RecvData[1]);	

	L0_uart0_uc(0x09);
	**********/

///	L0_uart0_ulhex(ts_oid.rec.d32[1]);L0_uart0_uc(0x09);	
	///

//	L0_uart0_sendArrayHex(ts_oid.rec.d,8);
	///L2_oid_ParseF1();

}
/******************************************************************************************************
Function:
Input:
Output:

BYTE0   BYTE1   BYTE2   BYTE3   BYTE4   BYTE5   BYTE6   BYTE7   
666655555555554444444444333333333322222222221111111111
3210987654321098765432109876543210987654321098765432109876543210
76543210        76543210        76543210        76543210        
        76543210        76543210        76543210        76543210
BYTE0   BYTE1   BYTE2   BYTE3   BYTE4   BYTE5   BYTE6   BYTE7    


U16[0]          U16[1]          U16[2]          U16[3]          
111111          111111          111111          111111
5432109876543210543210987654321054321098765432105432109876543210
666655555555554444444444333333333322222222221111111111
3210987654321098765432109876543210987654321098765432109876543210

u32[0]                          u32[1]                          
3322222222221111111111          3322222222221111111111          
1098765432109876543210987654321010987654321098765432109876543210
666655555555554444444444333333333322222222221111111111
3210987654321098765432109876543210987654321098765432109876543210

U16 	angle;		//	53–45 Angle 53,52 51 50 49,48 47 46 45
U8	Ydec;		//小数部分43–36 1111 0010b (Y decimal)
U8	Xdec;		//小数部分35–28 0111 0100b (X decimal) 
U8	Yint;		//整数部分 27–14 00 0000 0000 0100b (Y integer)
U8	Xint;		//整数部分 13–0 00 0000 0000 0100b (X integer)		

*******************************************************************************************************/
vU16 Lc_dec_us100(vU16 pint,u8 pdec)
{
	pint *= 100;
	if(pdec&0x80)///负数
	{
		pdec &= 0x7f;		
		pint -= 100;
	}else
	{

	}
	pdec *= 100;
	pdec /= 128;
	pint += (vU16)pdec;
	return pint;
			
}

void L2_oid_ParseF1(void)
{	
///	static uint8_t ucLogNum = 0;
	uint16_t u16i = 0;
	uint32_t u32t[2] = 0;
///	L1_print_rcv("\r\n F1=");
	ts_oid.oid_type = ts_oid.rec.d[0];
	
	L0_uart0_sendstr("ts_oid.rec.d[0] = ");
	L0_uart0_uchex(ts_oid.rec.d[0]);
	L0_uart0_0d0a();
		L0_uart0_sendstr("ts_oid.rec.d[1] = ");
	L0_uart0_uchex(ts_oid.rec.d[1]);
	L0_uart0_0d0a();
		L0_uart0_sendstr("ts_oid.rec.d[2] = ");
	L0_uart0_uchex(ts_oid.rec.d[2]);
	L0_uart0_0d0a();
		L0_uart0_sendstr("ts_oid.rec.d[3] = ");
	L0_uart0_uchex(ts_oid.rec.d[3]);
	L0_uart0_0d0a();

	/////////
	L0_uart0_sendstr("ts_oid.rec.d16[0] = ");
	L0_uart0_ushex(ts_oid.rec.d16[0]);
	L0_uart0_0d0a();
		L0_uart0_sendstr("ts_oid.rec.d16[1] = ");
	L0_uart0_ushex(ts_oid.rec.d16[1]);
	L0_uart0_0d0a();
	L0_uart0_sendstr("ts_oid.rec.d16[2] = ");
	L0_uart0_ushex(ts_oid.rec.d16[2]);
	L0_uart0_0d0a();
	L0_uart0_sendstr("ts_oid.rec.d16[3] = ");
	L0_uart0_ushex(ts_oid.rec.d16[3]);
	L0_uart0_0d0a();

	// /////////

		L0_uart0_sendstr("ts_oid.rec.d32[0] = ");
	L0_uart0_ulhex(ts_oid.rec.d32[0]);
	L0_uart0_0d0a();
		L0_uart0_sendstr("ts_oid.rec.d32[1] = ");
	L0_uart0_ulhex(ts_oid.rec.d32[1]);
	L0_uart0_0d0a();
	// /////////

	L0_uart0_sendstr("ts_oid.oid_type = ");
	L0_uart0_uchex(ts_oid.oid_type);
	L0_uart0_0d0a();


	if(1)// if(ts_oid.rec.d[0] == 0x60)  //  4
	{/// Bit43~Bit0：x,y 轴的坐标数据，x 坐标和 y 坐标都是由整数和小数部分
	///组成，整数部分 14bit，小数部分 8bit
		G.pen_t = 0; 
		ts_oid.last_time = s_nos_tick.t_1s;
		ts_oid.Xint = ts_oid.rec.d16[3] & 0x3fff;
	
		if(ts_oid.Xint < 300)///取决于图片 fixme: cc
		{
			ts_oid.oid_x = 1;
			
			u32t[0] = ts_oid.rec.d32[0];
			u32t[1] = ts_oid.rec.d32[1];
			
			ts_oid.angle  = (vU16)(u32t[0]>>13); //45-32= 13
			ts_oid.angle  &= 0x01ff;				//53-45+1=8
			///36-43
			ts_oid.Ydec = (ts_oid.rec.d[2]<<4) | (ts_oid.rec.d[3]>>4);	
			///28 35
			ts_oid.Xdec = (ts_oid.rec.d[3]<<4) | (ts_oid.rec.d[4]>>4);	
#ifdef docsdfads
			C0EC58E5   60 4D 24 23 A0 23 80 57	   (12800.4500,142.5156) 105
			C0EC58E5   60 4C E4 54 C0 23 40 5A	   (12800.5900,141.5391) 103
			C0EC58E5   60 4D 44 B5 A0 23 00 5D	   (12800.7000,140.5859) 106
			C0EC58E5   60 4D 24 AF 30 22 C0 61	   (12800.9000,139.5781) 105
			C0EC58E5   60 4D 24 B1 E0 22 80 64	   (12800.2300,138.5859) 105

			A0 23 80 57    (12800.4500,142.5156) 105
			A0        23        80        57 
			C0        23        40        5A
			A0        23        00        5D
			30        22        C0        61
			E0        22        80        64
			1010 0000 0010 0011 1000 0000 0101 0111
	        3322 2222 2222 1111 1111 11
	        1098 7654 3210 9876 5432 1098 7654 3210

#endif
			u32t[1] >>= 14;
			ts_oid.Yint = (vU16)u32t[1];
			ts_oid.Yint &= 0x3fff;		



#if 0
			if(ts_oid.Xdec&0x80)
			{
				ts_oid.x -= 1.0;
			}



			ts_oid.Xdec&=0x7f;
			ts_oid.x = (float)ts_oid.Xdec;
			ts_oid.x /= 128.0;	
			if(ts_oid.Xdec&0x80)
			{
				ts_oid.x -= 1.0;
			}
			ts_oid.x += ts_oid.Xint;

			ts_oid.Ydec&=0x7f;
			ts_oid.y = (float)ts_oid.Ydec;
			ts_oid.y /= 128.0;	
			if(ts_oid.Ydec&0x80)
			{
				ts_oid.y -= 1.0;
			}
			ts_oid.y += ts_oid.Yint;

#else
			ts_oid.X100 = Lc_dec_us100(ts_oid.Xint,ts_oid.Xdec);
			ts_oid.Y100 = Lc_dec_us100(ts_oid.Yint,ts_oid.Ydec);


#endif

			//数据存储到寄存器
			
			printf("	%hd 	%hd 	%hd	",
				ts_oid.X100,ts_oid.Y100,
				ts_oid.angle);
		}
		else
		{
			ts_oid.oid_type = 0;
			L0_uart0_uc(';');			
		}
	}
	else if(ts_oid.rec.d[0] == 0x40)///手写
	{
////	普通码（bit61=0）
////	Bit60：码是否有效（1：无效码；0：有效码）
////	Bit59~Bit28：保留
///	Bit27~Bit0：有效数据
	///	G.oid_p = 1;
		ts_oid.oid_p = 1;
		ts_oid.gCode = ts_oid.rec.d32[1]&0x0fFFffFF;

///R.oid3_order = (int)ts_oid.gCode *100;


		
		printf("  %ld    %x  ",ts_oid.gCode,(int)ts_oid.gCode);
		
		L0_uart0_ulhex(ts_oid.gCode);	
	}else
	{
		ts_oid.oid_type = 0;
		L0_uart0_uc(',');
	}
}
void L2_oid_status(void)
{
	if(G.oid_x)
	{
		if(ts_oid.pre_x == 0 && ts_oid.pre_y == 0&& ts_oid.X100 != 0 &&ts_oid.Y100 != 0)
		{
			G.pen_down = 1;
			//L0_uart2_sendstr("123");	
		}
		else if(ts_oid.pre_x != 0 && ts_oid.pre_y != 0&& ts_oid.X100 != 0 &&ts_oid.Y100 != 0)
		{
			G.pen_hold = 1;
			//L0_uart2_sendstr("456");	
		}
	}
	
}

uint8_t L1_OID_WakeUp(void)
{
	uint32_t i = 0;
	LD_Oid_SCK_LOW();
	delay_ms(2);
	LD_Oid_SCK_HIGH();
	delay_ms(30);
	LD_Oid_SCK_LOW();
	
	L0_uart0_sendstr("	44 ");

	while(1)
	{
		delay_ms(10);
		i += 1;
		if(i >= 400)  // 400*5ms = 2s
		{
			L0_uart0_sendstr("	!!out!!	");
			return 0;
		}
		if(!OID_DET)
		{
			L0_oid_Recv64();
			L1_print_rcv("\r\n WakeUpOID get=");
				if(ts_oid.rec.d[7] == 0xf8)						
				{	
						///use
						L0_uart0_sendstr(" ok\r\n");
						return 1;//ucCheckVersionAndInit(eAppDevice);
					
				}
				else
				{
					L0_uart0_sendstr("\r\nno?? OIDCMD_POWER_ON \r\n");
					return 0;
				}
		}
	}
}


/******************************************************************************************************
Function:
Input:
Output:
*******************************************************************************************************/
void L0_Oid_Init(void)
{
	LD_Oid_DIO_INIT();
	/******************************************************************************************************
		5430C2000A/3000A点读应用初始化设置    
		顺序	命令设置	备注
		1	single command 0x4D 关闭解码
		2	REG(0xD40) = 0x00	设置仅读OID码，0X00仅读OID3/OID2,0X10仅读OID3S，0X20仅读OID4
		3	single command 0x36 关闭手写码侦测
		4	"REG(0x0DAD) = 4250   //设置AE Target
		REG(0x0DB1) = 4000	 //设置AE LOW
		REG(0x0DAF) = 4000	 //设置AE LOW
		REG(0x0DB0) = 4500	 //设置AE HIGH
		REG(0x0DAE) = 4500	 //设置AE HIGH
	
		REG(0x1641) = 0xA0	 //设置dot filter
		REG(0x0D6A) = 0x3F	 //此项不要改动
		REG(0x0D2C) = 0x3F	 //此项不要改动" "初始化，可不下此部分命令，若笔头配合底码识别不佳，可以下此部分命令，设置不同参数尝试。
	
		设置AE Range和dot filter。
		AE_LOW < AE_Target <AE_HIGH.
		Dot filter，要设置整数倍，比如0x40,0x50,0x60……。"
		5	……	用户命令，用户根据产品应用决定需要下的命令。
		6	REG(0xD63) = 0x80	打开解码。此命令错误改为如下命令。
		6	"i = REG(0xD63）
		i &= 0xFFFE
		REG(0xD63) = i" 打开解码,方法是把寄存器0xD63中的数据的bit0清零，其它bit不可动。
	
	*******************************************************************************************************/
	L0_uart0_sendstr("\r\nL1_OID_WakeUp3 ");
	L1_OID_WakeUp();
	L0_uart0_sendstr("666666");
	/***	

	L1_oid_TransCmd(0x4D);////	1	single command 0x4D 关闭解码

	Write_Register(0x0D40,0x00); ////	2	REG(0xD40) = 0x00	设置仅读OID码，0X00仅读OID3/OID2,0X10仅读OID3S，0X20仅读OID4

		L1_oid_TransCmd(0x36);///3	single command 0x36 关闭手写码侦测
	Write_Register(0x0DAD,4250); //设置 AE Target 4	"REG(0x0DAD) = 4250   //设置AE Target
	Write_Register(0x0DB1,4000); //设置 AE LOW
	Write_Register(0x0DAF,4000); //设置 AE LOW
	Write_Register(0x0DB0,4500); //设置 AE High
	Write_Register(0x0DAE,4500); //设置 AE High  0x1194
	Write_Register(0x1641,0xA0); //设置 dot filter
	Write_Register(0x0D6A,0x3F);  //此项不要改动
	Write_Register(0x0D2C,0x3F); //此项不要改动" "初始化，可不下此部分命令，若笔头配合底码识别不佳，可以下此部分命令，设置不同参数尝试。
		******/
	
	Write_Register(0x0D63,0x80);  //cc 好像数据分辨率有区别 此项不要改动	6	REG(0xD63) = 0x80	打开解码。此命令错误改为如下命令。
	
	///L1_oid_CheckVersionAndInit();///cc 仍然有读取错误的时候

	//			6	"i = REG(0xD63）
	//			i &= 0xFFFE
	//			REG(0xD63) = i" 打开解码,方法是把寄存器0xD63中的数据的bit0清零，其它bit不可动。
		L1_oid_TransCmd(USERCMD_20FPS);//cc 必须添加
		L1_oid_TransCmd(USERCMD_EN_ANGLE);//cc 必须添加
		L1_oid_TransCmd(USERCMD_EN_POSITION);//cc 必须添加

		
		printf("\r\n L0_Oid_Init finish\r\n");

///while(9)
{
	L1_Oid_readoid();

}

}

void L1_Oid_readoid(void)
{	
	if(!OID_DET)
	{	
		LED1 = ~LED1;
		ts_oid.pre_x = ts_oid.X100;
		ts_oid.pre_y = ts_oid.Y100;
		L0_oid_Recv64();
		L2_oid_ParseF1();
		//L2_oid_status();
		L1_print_rcv("\r\n ");
		L0_uart0_sendstr("ts_oid.Xint = ");
		L0_uart0_ushex(ts_oid.Xint);
		L0_uart0_0d0a();
		L0_uart0_sendstr("ts_oid.Yint = ");
		L0_uart0_ushex(ts_oid.Yint);
		L0_uart0_0d0a();
		L0_uart0_sendstr("ts_oid.Xdec = ");
		L0_uart0_ushex(ts_oid.Xdec);
		L0_uart0_0d0a();
		L0_uart0_sendstr("ts_oid.Ydec = ");
		L0_uart0_ushex(ts_oid.Ydec);
		L0_uart0_0d0a();
		L0_uart0_sendstr("oid_p");
	}
	else if((s_nos_tick.t_1s - ts_oid.last_time >= 2)&& (G.pen_t == 0))
	{
		G.pen_up = 1;
		G.pen_t =1;
		//L0_uart2_sendstr("789");	
	}
///	delay_us(100);
}


#if 0

step1 
if(!OID_DET)
{
	L0_oid_Recv64();

step2

L2_oid_ParseF1();
step 3
	状态



///#ifdef doc980808
验证算法的正确性
unsigned char s[64]=
		{
		
		1	,	//	0	
		1	,	//	1	
		1	,	//	2	
		1	,	//	3	
		1	,	//	4	
		1	,	//	5	
		1	,	//	6	
		1	,	//	7	xxxx
		
		1	,	//	8	
		1	,	//	9	
		1	,	//	10	
		1	,	//	11	
		1	,	//	12	
		1	,	//	13	
		1	,	//	14	
		1	,	//	15	xxxx
		
		1	,	//	16	
		1	,	//	17	
		1	,	//	18	
		1	,	//	19	
		1	,	//	20	
		1	,	//	21	
		1	,	//	22	
		1	,	//	23	xxxx
		
		1	,	//	24	
		1	,	//	25	
		1	,	//	26	
		1	,	//	27	
		1	,	//	28	
		1	,	//	29	
		1	,	//	30	
		1	,	//	31	xxxx
		
		1	,	//	32	
		1	,	//	33	
		1	,	//	34	
		1	,	//	35	
		1	,	//	36	
		1	,	//	37	
		1	,	//	38	
		1	,	//	39	xxxx
		
		1	,	//	40	
		1	,	//	41	
		1	,	//	42	
		1	,	//	43	
		1	,	//	44	
		1	,	//	45	
		1	,	//	46	
		1	,	//	47	xxxx
		
		1	,	//	48	
		1	,	//	49	
		1	,	//	50	
		1	,	//	51	
		1	,	//	52	
		1	,	//	53	
		1	,	//	54	
		1	,	//	55	xxxx
		
		1	,	//	56	
		1	,	//	57	
		1	,	//	58	
		1	,	//	59	
		1	,	//	60	
		1	,	//	61	
		1	,	//	62	
		1		//	63	xxxx
		
		};
		int x =0;
int i;


void t(void)
{RecvData[0] = 0;RecvData[1] = 0;
	for(i = 0; i < 64; i++)
	{


		if(s[63-i])
		{
			if(i < 32)
			{
				RecvData[0] += 1;
			}
			if(i>=32 && i<64)
			{
				RecvData[1] += 1;
			}
		
		}
		if(i < 31)
		{
			RecvData[0] <<= 1;
		}
		if( i >31 && i < 63)
		{
			RecvData[1] <<= 1;
		}


	}
	
	for(i = 0; i < 64; i++)
	{
		ts_oid.d[i/8] <<= 1;
		if(s[63-i])
		{
			ts_oid.d[i/8] |= 1;
		}
		else
		{
			ts_oid.d[i/8] &= 0xfe;
		}
	}
i =5;

}


#endif