pcsyn_protocol.c

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

#include <windows.h>
#include <string.h>

#include "pcsyn_protocoldll.h"
//#include "uart.h"
//#include "pcsyn.h"
#include "pcsyn_serial.h"
#include "pcsyn_protocol.h"

//存储串口进来的包
#define MAX_IN 256
static BYTE buff_in[MAX_IN];
static BYTE size_buff_in = 0;

//存储要写到串口的包
#define MAX_OUT 256
static BYTE buff_out[MAX_OUT];
static BYTE size_buff_out = 0;


//用于重发
static BYTE buff_out_resend[MAX_OUT];
static BYTE size_buff_out_resend  = 0;

#define MAX_INTOTAL   364000
static BYTE buff_intotal[MAX_INTOTAL];
static int  size_buff_intotal = 0;

#define MAX_OUTTOTAL 364000
BYTE buff_outtotal[MAX_OUTTOTAL];
static int  size_buff_outtotal = 0;
static int  transfer_buff_outtotal = 0;

HWND hwndProtocol;
//#define SIZESENDUINT 26

PC_Packet_UL pc_packet_ul;
PC_Packet_DL pc_packet_dl;

/* no response from target */
static int timeout_nores = 0;
/* no data from target, fix to PC_Error_WaitData*/
static int timeout_nodata = 0;

static PC_Protocol pc_protocol=
{
 	STX,
	ETX,
	DLE,
	HEADER_UL,
	HEADER_DL,
	0,			//frameid
	0x00,         //frametype
	PC_NOCONNECT
};

static  PC_Interface_Info *interface_info;

BYTE pc_checksum(BYTE *buf, int size);
int pc_readbuffer(BYTE *buffer ,int size,int type);
VOID TimerProc(
			   HWND hwnd,         // handle to window
			   UINT uMsg,         // WM_TIMER message
			   UINT_PTR idEvent,  // timer identifier
			   DWORD dwTime       // current system time
			   );
int read_packetDL(BYTE *buffer, unsigned int size);

#define  PCSYN_TIMEOUT 100
#define  PCSYN_TIMERID 0x01

static unsigned int pcsyn_tmID = 0; 
static unsigned int pcsyn_timeout = 0;

BYTE isdle(BYTE b)
{
	if(b == pc_protocol.stx ||
	   b == pc_protocol.dle ||
	   b == pc_protocol.etx)
	   return 0x01;
	return 0x00;
}

int pc_connect()
{
	pcsyn_timeout = 0;

	pc_packet_ul.frametype = 0x40;
	pc_packet_ul.frameid = PC_FRAME_MIN;
	pc_packet_ul.datasize = 0xff;
//	pc_writebyulpkt();

	size_buff_out_resend = 0;
	buff_out_resend[size_buff_out_resend ++ ] = pc_protocol.header_ul;
	buff_out_resend[size_buff_out_resend ++ ] = PC_FT_Control | PC_CF_Connect;
	buff_out_resend[size_buff_out_resend ++ ] =PC_FRAME_MIN;
	buff_out_resend[size_buff_out_resend ++ ] = pc_checksum(buff_out_resend, size_buff_out_resend);
	
	send_pcsyn_event(1);

	pcsyn_tmID = SetTimer(hwndProtocol,PCSYN_TIMERID ,PCSYN_TIMEOUT,(TIMERPROC )TimerProc);
	return  PC_Error_NoError;
}
int pc_disconnect()
{
	size_buff_intotal = 0;
	size_buff_outtotal= 0;

	pc_packet_ul.frametype = 0x41;
	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;
	pc_writebyulpkt();

	
	return  PC_Error_NoError;
}
int  serial2protocol(BYTE *buffer,int size)
{
	if(size > MAX_IN && size<5)
		return 1;
	size_buff_in = size;
	memcpy(buff_in,buffer,size);
	send_pcsyn_event(0);
	return 0;
}

void indicate_resend()
{
	pcsyn_timeout =100;
}


int pc_dldata()
{
	
	memcpy(&interface_info->pdata_dlbuff[interface_info->size_dlbuff],pc_packet_dl.data,pc_packet_dl.datasize);
	
	interface_info->size_dlbuff += pc_packet_dl.datasize;
	return PC_Error_NoError;				
}

//tx data
int pc_txdata()
{
	BYTE size = 3;
	BYTE iuldata = 0;

	pc_packet_ul.frametype = PC_IF_Data | PC_FT_Info;

	if(isdle(pc_packet_ul.frametype))
		size ++;
	
	if(pc_packet_ul.frameid == PC_FRAME_MAX)
	{
		pc_packet_ul.frameid = PC_FRAME_MIN;
	}
	else
	{
		pc_packet_ul.frameid ++;
	}

	if(isdle(pc_packet_ul.frameid))
		size ++;
	while(size < PACKET_MAXSIZE && transfer_buff_outtotal < size_buff_outtotal)
	{
		pc_packet_ul.data[iuldata] = buff_outtotal[transfer_buff_outtotal++];
		if(isdle( pc_packet_ul.data[iuldata] ))
			size ++;
		size++;
		iuldata ++;

	}
	//memcpy(pc_packet_ul.data , buff_outtotal + transfer_buff_outtotal, pc_packet_ul.datasize);
	pc_packet_ul.datasize = iuldata;
	
	
	pc_writebyulpkt();		
}




int handle_inbuffer()
{
	int status = 0;

/* if receive packet from target,reset timeout_nores to 0*/	
	timeout_nores = 0;
	
	
	if(pc_checksum(buff_in,size_buff_in) != (BYTE)pc_protocol.header_dl )
	{//checksum error
		return PC_Error_CheckSum;
	}
/*
	if(size_buff_in<4)
	{//invalid bufffer size
		return PC_Error_InvalidPktSize;
	}
*/
	read_packetDL(buff_in ,size_buff_in - 1 );
	if(pc_packet_dl.status == PC_Error_WaitData)
	{
		return PC_Error_WaitData;
	}
	//checkframe id
	if(pc_packet_ul.frameid !=  pc_packet_dl.frameid)
	{
		indicate_resend();
		return PC_Error_InvalidFrameid;
	}

	//checkframe type
	if(pc_packet_ul.frametype != pc_packet_dl.frametype_ul)
	{
		indicate_resend();
		return PC_Error_InvalidFrameType;
	}
	
	if(pc_packet_dl.status >= 0x80)//application error
	{
		interface_info->status = pc_packet_dl.status;
	/*	if(interface_info->callback)
		{
			
			interface_info->callback((void*) interface_info);
		}
		*/
		//disconnect it
		return pc_packet_dl.status;
	}
	
	
		
	switch(pc_packet_dl.frametype_ul & 0xc0)

	{
	case PC_FT_Monitor:// monitor frame
		if(pc_protocol.status == PC_NOCONNECT)
		{
			return PC_Error_NoConnect;
		}
		break;
	case PC_FT_Control: //control frame
		switch(pc_packet_dl.frametype_ul & 0x3f)
		{
			case PC_CF_Connect:
				if(pc_protocol.status == PC_NOCONNECT)// a connect
				{
					pc_protocol.status = PC_CONNECTED;
				}
				else
				{
					return PC_Error_ConnectExisted;
				}
				break;
			case PC_CF_Cmd://begin rx data or tx data
				switch(pc_protocol.status)
				{
					case PC_CONNECTED:
						//pc_protocol.status  = PC_CMDRECV;
						if(interface_info->flag == PC_IF_FLAGS_DATAUL)
						{
							pc_protocol.status = PC_DATAUL;
						}
						else if(interface_info->flag == PC_IF_FLAGS_DATADL)
						{
							pc_protocol.status = PC_DATADL;
						}
						break;
					default:
						return PC_Error_InvalidFrameType;
				}
				break;

			case PC_CF_DataEnd:
				switch(pc_protocol.status)
				{
					case PC_DATAULEND:
					case PC_DATADLEND:
					
						pc_protocol.status = PC_WAITDISCONNECT;
						break;
					default:
						return PC_Error_InvalidFrameType;
				}
				break;

			case PC_CF_DisConnect:
				switch(pc_protocol.status)
				{
				case PC_WAITDISCONNECT:
					pc_protocol.status = PC_NOCONNECT;
					KillTimer(hwndProtocol,pcsyn_tmID);
					//success a transaction
					if(interface_info->callback)
					{
						interface_info->callback((void*) interface_info);
					}
					break;
				default:
					return PC_Error_InvalidFrameType;
				}
				break;
			default:
				return PC_Error_InvalidFrameType;
		}
		break;
	case PC_FT_Info://info frame
		if(pc_protocol.status == PC_NOCONNECT)
		{
			return PC_Error_NoConnect;
		}
		switch(pc_packet_dl.frametype_ul & 0x3f)
		{
		case PC_IF_Data:
			switch(pc_protocol.status)
			{
				case PC_CMDRECV:
					pc_protocol.status = PC_DATAUL;
					pc_protocol.frameid = PC_FRAME_MIN - 1;
					size_buff_intotal = 0;
					break;
				case PC_DATAUL:
					//pcsyndebug("data rx\n",strlen("data rx\n"));
					//status = pc_rxdata();
					if(pc_packet_ul.datasize == 0 )
						pc_protocol.status = PC_DATAULEND;
					break;
				case PC_DATADL://tx
					status = pc_dldata();
					if(pc_packet_dl.datasize == 0)
					{
						pc_protocol.status = PC_DATADLEND;
					}
					
					break;
					//if(size_buff_out == 0)
					//	pc_protocol.status = PC_DATATXEND;
				case PC_DATAULEND://tx end
					break;
				case PC_DATADLEND:
					break;
				default:
					status = PC_Error_InvalidFrameType;
					break;
			}
		       break;
			case PC_IF_DataAck:
				break;
		default:
			status = PC_Error_InvalidFrameType;
			break;
		}

		break;
	default://incalid frame type
		return PC_Error_InvalidFrameType;
	}
	return status;
}