pcsyn_protocol.c

是一个手机功能的模拟程序

BYTE pc_checksum(BYTE *buf, int size)
{
    int cksum = 0;

    while (size--)
        cksum ^= *buf++;
	
    return cksum;
}


/******************************************************/
int read_packetDL(BYTE *buffer, unsigned int size)
{
	if((unsigned int)buffer[iDL_DATASIZE] != size - iDL_DATA)
		return PC_Error_InvalidDataSize;
	memcpy(&pc_packet_dl.frametype, buffer ,size);
	return PC_Error_NoError;
}
/******************************************************/


/*****************************************/

VOID TimerProc(
			   HWND hwnd,         // handle to window
			   UINT uMsg,         // WM_TIMER message
			   UINT_PTR idEvent,  // timer identifier
			   DWORD dwTime       // current system time
			   )
{

	pcsyn_timeout++;

	if(pcsyn_timeout > 5)
	{
		timeout_nores++;
		//protocol2serial(buff_out_resend,size_buff_out_resend);
		if(timeout_nores >= 10)
		{
			timeout_nores = 0;
/* error,说明target响应timeout，for example：serial is invalid*/
			if(interface_info->callback)
			{
				interface_info->status = PC_Error_SerialNoResponse;
				interface_info->callback((void*) interface_info);
				KillTimer(hwndProtocol,pcsyn_tmID);
			}
			pc_disconnect();
		}
		else
		{
			send_pcsyn_event(1);
		}
		pcsyn_timeout = 0;
		
	}
}

/*********************************************
ack info
-------------------------------------------------------------
| frametype | frameid | status | frametype from  pc |datasize |  data |
---------------------------------------------------------------
|   81	    |	 00       |           |                           |            |        |
-----------------------------------------------------------------
**********************************************/
int pc_writebystatus(int status)
{
	int size = 0;
	BYTE * pbuff;

	if(status >= 0x80)/*a app error occur,disconnect the session*/
	{
		pc_protocol.status = PC_WAITDISCONNECT;
		if(interface_info->callback)
		{
			interface_info->callback((void*) interface_info);
			interface_info->callback = 0;
		}
		status = PC_Error_NoError;
	}

	
	switch(status)
	{
	case PC_Error_NoError:
		switch(pc_protocol.status)
		{
		case PC_CONNECTED:
			pc_packet_ul.frametype = PC_FT_Control | PC_CF_Cmd;
			
			if(pc_packet_ul.frameid == PC_FRAME_MAX)
			{
				pc_packet_ul.frameid = PC_FRAME_MIN;
			}
			else
			{
				pc_packet_ul.frameid ++;
			}
			pc_packet_ul.datasize = size_buff_out;
			memcpy(pc_packet_ul.data , buff_out, size_buff_out);
			pc_writebyulpkt();
			break;
		case PC_DATAUL://tx data
			pc_txdata();
			break;
		case PC_DATAULEND:
		case PC_DATADLEND:
			pc_packet_ul.frametype = PC_FT_Control | PC_CF_DataEnd;
			
			if(pc_packet_ul.frameid == PC_FRAME_MAX)
			{
				pc_packet_ul.frameid = PC_FRAME_MIN;
			}
			else
			{
				pc_packet_ul.frameid ++;
			}
			pc_packet_ul.datasize = 0xff;
			//memcpy(pc_packet_ul.data , buff_out, size_buff_out);
			pc_writebyulpkt();
			break;

		case PC_DATADL://rx data
			pc_packet_ul.frametype = PC_IF_Data | PC_FT_Info;
			
			if(pc_packet_ul.frameid == PC_FRAME_MAX)
			{
				pc_packet_ul.frameid = PC_FRAME_MIN;
			}
			else
			{
				pc_packet_ul.frameid ++;
			}
			pc_packet_ul.datasize = 0;

			

			pc_writebyulpkt();
			
			break;
		case PC_WAITDISCONNECT:
			pc_disconnect();
			break;
		case PC_NOCONNECT:
			break;
		default:
			break;
		}
		
		break;
	case PC_Error_FrameIsReRX:
		//UA_EncapsulateNChars(0, buff_out_resend, size = size_buff_out_resend);
		break;
	case PC_Error_WaitData:
		break;
	case PC_Error_MMINotAllow:
		KillTimer(hwndProtocol,pcsyn_tmID);
	default:
	
		break;
	}

	return size;
}

int pc_writebyulpkt()
{
	static BYTE buffer[256];
	int size = 0;
	BYTE * pbuff;

	pbuff = (BYTE *)buffer;

	pbuff [size++] = pc_packet_ul.frametype;
	pbuff [size++] = pc_packet_ul.frameid;
	if(pc_packet_ul.datasize != 0xff)
	{
		pbuff [size++] = pc_packet_ul.datasize;

		memcpy(pbuff  + size, pc_packet_ul.data, pc_packet_ul.datasize);
		size += pc_packet_ul.datasize;
	}
	return pc_write_serial(pbuff, size);
}
/*********************************************
ack info
-------------------------------------------------------------
| head |    data                 | checksum|
---------------------------------------------------------------
|   80  |	  pc_writebystatus |             |
-----------------------------------------------------------------
**********************************************/
int pc_write_serial(BYTE* buf ,int size)
{
	static BYTE buffer[256];
	int size_buffer = 0;
	BYTE * pbuff = buffer;
	
	//set tim out
	pcsyn_timeout = 0;
	
	
	pbuff[size_buffer ++ ] = pc_protocol.header_ul;
	memcpy(pbuff + size_buffer, buf ,size);
	size_buffer += size;
	pbuff[size_buffer ++ ] = pc_checksum(pbuff,size_buffer);

	//保留重发包
	memcpy(buff_out_resend,pbuff ,size_buff_out_resend = size_buffer);
	
	protocol2serial(pbuff, size_buffer);

	return 0;
}



/***************************************/
//call bu user, transmit a quest
int pc_writebuffer(BYTE *bufcmd ,int size_bufcmd,BYTE *buf_context,int size_buf_context)
{
	//initialize
	pc_protocol.frameid = PC_FRAME_MIN;
	pc_protocol.status = PC_NOCONNECT;
	memcpy(buff_out, bufcmd, size_buff_out = size_bufcmd);
	
	size_buff_outtotal = 0;
	transfer_buff_outtotal = 0 ;
	if(buf_context)	
	{
		memcpy(buff_outtotal,buf_context  ,size_buff_outtotal = size_buf_context);
	}

	//connect
	pc_connect();
	
	return 0;
}

//imple by user
int pc_readbuffer(BYTE *buffer ,int size)
{
	return 0;
}

int  pc_resend()
{
	return protocol2serial(buff_out_resend,size_buff_out_resend);
}

int pc_sendmonitor()
{
	return 0;
}
//demo,imple by protocol ,call by user
DllExport int pc_interface(PC_Interface_Info * info)
{
	BYTE *p; 

#ifdef FILE_DEBUG
	emptyMonitorFile();
#endif
	interface_info = info;
	//initialize
	pc_protocol.frameid = PC_FRAME_MIN;
	pc_protocol.status = PC_NOCONNECT;
	memcpy(buff_out, info->pdata_cmd, size_buff_out = info->size_cmd);
	
	
	switch(info->flag)
	{
	case PC_IF_FLAGS_DATAUL:
		p = buff_outtotal;
		size_buff_outtotal = 0;
		transfer_buff_outtotal = 0;
		
		if(info->pdata_ulbuff)	
		{
			memcpy(p, &info->size_ulbuff, sizeof(info->size_ulbuff));
			p += sizeof(info->size_ulbuff);
			size_buff_outtotal+= sizeof(info->size_ulbuff);
			memcpy(p,info->pdata_ulbuff  , info->size_ulbuff);
			size_buff_outtotal += info->size_ulbuff;
		}
		break;	
	case PC_IF_FLAGS_DATADL:
		interface_info->size_dlbuff = 0;
		break;
	default:
		//error flag
		break;
		
	}
	//connect
	pc_connect();
	return 0;
	
}

DllExport void pcsyn_protocol_init()
{
	extern HANDLE hApp;

	TCHAR   szTitle[] = TEXT("PCSyn_Protocol");      // The title bar text
	TCHAR   szWindowClass[] = TEXT("Window PCSyn_Protocol");      // The window class name
	MSG msg;
	WNDCLASS   wc; // The window class for this application
	
	// Register the window class:
	
	wc.style             = CS_HREDRAW | CS_VREDRAW;
	wc.lpfnWndProc      = (WNDPROC) DefWindowProc; //The function to handle the window messages
	wc.cbClsExtra      = 0;
	wc.cbWndExtra      = 0;
	wc.hInstance      = hApp;
	wc.hIcon           = 0;
	wc.hCursor         = 0;
	wc.lpszMenuName      = 0;
	wc.hbrBackground = COLOR_WINDOW;
	wc.lpszClassName   = szWindowClass;
	
	if (!RegisterClass(&wc)) 
		return FALSE;//Failed to register the window
	
	// Create the main window
	
	hwndProtocol = CreateWindow(szWindowClass, szTitle, 0,
		CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hApp, NULL);
	ShowWindow(hwndProtocol, SW_HIDE);

	pcsyn_start_task();
}

DllExport void pcsyn_protocol_close()
{
	DestroyWindow(hwndProtocol);
	pcsyn_stop_task();
}