pcsyn_protocol.c

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

/*
+-------------------------------------------------------------------+
| PROJECT: PC Synchronization                    
| $Workfile: pcsyn_protocol.c
| $Author: Talcon Hu
| $History:
| 	2004.05.18,talcon create                 
| 	2004.07.15,talcon modify memory alloc,uese MI_mmimem_Alloc
+-------------------------------------------------------------------+
*/
#define ENTITY_PCSYN
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#if defined (NEW_FRAME)

#include "typedefs.h"
#include "vsi.h"
#include "pei.h"
#include "custom.h"
#include "gsm.h"

#else

#include "stddefs.h"
#include "custom.h"
#include "gsm.h"
#include "vsi.h"

#endif

#define PCSYN_COMPILE_FORAPP
#include "pcsyn.h"

#include "pcsyn_protocol.h"
//#include "pcsyn_application.h"

#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   64000
static BYTE* buff_intotal = 0;//[MAX_INTOTAL];
static int  size_buff_intotal = 0;

//#define MAX_OUTTOTAL 64000
static BYTE *buff_outtotal = 0;//[MAX_OUTTOTAL];
static int  size_buff_outtotal = 0;
static int  transfer_buff_outtotal = 0;

static PC_Packet_UL pc_packet_ul;
static PC_Packet_DL pc_packet_dl;

static  PC_Interface_Info interface_info;

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

extern BYTE g_pcsynwnd ;


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

int pc_disconnect()
{
	size_buff_intotal = 0;
	size_buff_outtotal= 0;
	pc_protocol.status = PC_NOCONNECT;
	pc_packet_dl.frameid = PC_FRAME_MIN - 1;
}


//pc -->target
int pc_uldata()
{
	BYTE *pdata = pc_packet_ul.data;
	int datasize = pc_packet_ul.datasize;
	if(size_buff_intotal == 0 && buff_intotal ==0)/*first ,alloc momory*/
	{
		int size ;
		/*get size by the first four bytes*/
		memcpy(&size, pc_packet_ul.data, sizeof(size));
		PCSYN_new(buff_intotal, size);
		if(g_codepcsynmem !=0)
			return PC_Error_MemoryAlloc;
		pdata += sizeof(size);
		datasize -= sizeof(size); 
	}
	memcpy(&buff_intotal[size_buff_intotal], pdata, datasize);

	size_buff_intotal += datasize;
	return PC_Error_NoError;				
}


//target -->pc
int pc_dldata(BYTE status)
{
	BYTE size = 6;
	BYTE idldata = 0;
	
	pc_packet_dl.frametype = PC_FT_Info | PC_IF_DataAck;
	if( isdle(pc_packet_dl.frametype) ) size++;
	
	pc_packet_dl.frameid = pc_packet_ul.frameid;
	if( isdle(pc_packet_dl.frameid) ) size++;
	
	pc_packet_dl.status = (BYTE)status;
	if( isdle(pc_packet_dl.status) ) size++;
	
	pc_packet_dl.frametype_ul = pc_packet_ul.frametype;
	if( isdle(pc_packet_dl.frametype_ul) ) size++;

	while(size < PACKET_MAXSIZE && transfer_buff_outtotal < interface_info.size_dlbuff)
	{
		pc_packet_dl.data[idldata] = interface_info.pdata_dlbuff[transfer_buff_outtotal++];
		if(isdle( pc_packet_dl.data[idldata] ))
			size ++;
		size++;
		idldata ++;
	}
	pc_packet_dl.datasize = idldata;

	pc_writebydlpkt();
	return PC_Error_NoError;		
}


/******************************************************/
int read_packetUL(BYTE *buffer, unsigned int size)
{
	if(size > iUL_DATASIZE && (unsigned int)buffer[iUL_DATASIZE] != size - iUL_DATA )
		return PC_Error_InvalidDataSize;
	else if( size == iUL_DATASIZE)
		pc_packet_ul.datasize = 0xff;
	memset(pc_packet_ul.data, 0 , sizeof(pc_packet_ul.data) );//??????????????????
	memcpy(&pc_packet_ul.frametype, buffer ,size);
	return PC_Error_NoError;
}
/******************************************************/


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

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



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

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

	PCSYN_TRACE_EVENT(("pc_writebystatus : %d, %d", status, pc_protocol.status));
	switch(status)
	{
	case PC_Error_FrameIsReRX: 
		pc_writebydlpkt();
		break;
	case PC_Error_MMINotAllow:
		pc_packet_dl.frametype = PC_FT_Info | PC_IF_DataAck;
		pc_packet_dl.frameid = pc_packet_ul.frameid;
		pc_packet_dl.status = (BYTE)status;
		pc_packet_dl.frametype_ul = pc_packet_ul.frametype;
		pc_packet_dl.datasize =  0;
 		pc_writebydlpkt();
		break;
	case PC_Error_WaitData: 
		pc_packet_dl.frametype = PC_FT_Info | PC_IF_DataAck;
		pc_packet_dl.frameid = pc_packet_ul.frameid;
		pc_packet_dl.status = (BYTE)status;
		pc_packet_dl.frametype_ul = pc_packet_ul.frametype;
		pc_packet_dl.datasize =  size_buff_out;
		memcpy(pc_packet_dl.data, buff_out, size_buff_out);
		pc_writebydlpkt();

		break;
	default:
		switch(pc_protocol.status)
		{
		case PC_DATADL:
			 pc_dldata((BYTE)status);
		 	break;
		default: 
			pc_packet_dl.frametype = PC_FT_Info | PC_IF_DataAck;
			pc_packet_dl.frameid = pc_packet_ul.frameid;
			pc_packet_dl.status = (BYTE)status;
			pc_packet_dl.frametype_ul = pc_packet_ul.frametype;
			pc_packet_dl.datasize =  size_buff_out;
			memcpy(pc_packet_dl.data, buff_out, size_buff_out);
			
			pc_writebydlpkt();
			break;
		}
		
		break;
	}
	return size;
}

//zkc add	07/22/04
int pc_writebyinfo(unsigned int status)
{
	int size = 0;
	
	pc_packet_dl.frametype = PC_FT_Info | PC_IF_DataAck;
	pc_packet_dl.frameid = pc_packet_ul.frameid;
	pc_packet_dl.status = (BYTE)status;
	pc_packet_dl.frametype_ul = pc_packet_ul.frametype;
	pc_packet_dl.datasize =  size_buff_out;
	memcpy(pc_packet_dl.data, buff_out, size_buff_out);

	interface_info.status = PC_Error_NoError;
		
	pc_writebydlpkt();
		
	return size;
}

int pc_writebydlpkt()
{
	pc_write_serial(&pc_packet_dl.frametype, pc_packet_dl.datasize + iDL_DATA );
}

//
int pc_write_serial(BYTE* buf ,int size)
{
	PCSYN_TRACE_EVENT(("pc_write_serial:%d",size));
	size_buff_out = 0;
	buff_out[size_buff_out ++ ] = pc_protocol.header_dl;
	memcpy(buff_out+size_buff_out, buf ,size);
	size_buff_out += size;
	buff_out[size_buff_out ] = pc_checksum(buff_out,size_buff_out);
	size_buff_out ++;

	SER_tr_WriteNBytes(1, buff_out, size_buff_out);
	PCSYN_TRACE_EVENT(("end SER_tr_WriteNBytes"));
	return 0;
}




/*************************************************
$Descriptio: 处理从串口进来的数据，并填充要给pc的数据结构
******************************************************/
int handle_inbuffer(BYTE *buff_in,unsigned short size_buff_in)
{
	int status = 0;
	BYTE frametype1,frametype2;
	BYTE cid1 = 0,cid2 = 0;

	size_buff_out = 0;
		
	if(pc_checksum(buff_in,size_buff_in) != pc_protocol.header_ul)
	{//checksum error
		return PC_Error_CheckSum;
	}

	
	
	size_buff_in --;
	//read uldata
	status = read_packetUL(buff_in,size_buff_in);

	if( g_pcsynwnd == 0)
	{
		return PC_Error_MMINotAllow;
	}
	
	if(status != PC_Error_NoError)
	{
		return status;
	}

	frametype1 = pc_packet_ul.frametype & 0xc0;
	frametype2 = pc_packet_ul.frametype & 0x3f;
	if(frametype1 !=PC_FT_Control 
		||
		(frametype2 != PC_CF_Connect &&  frametype2 != PC_CF_DisConnect)
		)
	{
		//checkframe id
		if(pc_packet_dl.frameid == pc_packet_ul.frameid  )
		{
			if(interface_info.status == PC_Error_WaitData)
				return PC_Error_WaitData;
			else
				return PC_Error_FrameIsReRX;
		}

		//frameid is illegal
		if( (pc_packet_ul.frameid !=  pc_packet_dl.frameid + 1) 
			&& pc_packet_ul.frameid != PC_FRAME_MIN 
			&&  pc_packet_dl.frameid!= PC_FRAME_MAX)
			return PC_Error_InvalidFrameid;
	}
		//handle by frametype
	switch(frametype1)

	{
	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_ul.frametype & 0x3f)
		{
			case PC_CF_Connect:
				//if(pc_protocol.status == PC_NOCONNECT)// a connect
				{
					if(buff_outtotal)
					{
						PCSYN_free(buff_outtotal,size_buff_outtotal);
					}
					if(buff_intotal)
					{
						PCSYN_free(buff_intotal,size_buff_intotal);
					}
					pc_protocol.status = PC_CONNECTED;
					pc_protocol.frameid = PC_FRAME_MIN - 1;
				}
				//else
				{
					//return PC_Error_ConnectExisted;
				}
				break;
			case PC_CF_Cmd://cmd quest
				switch(pc_protocol.status)
				{
					case PC_CONNECTED:
//						status = pc_readbuffer(pc_packet_ul.data,(int)pc_packet_ul.datasize,0)

						interface_info.flag = PC_IF_FLAGS_CMD;
						interface_info.pdata_cmd = pc_packet_ul.data;
						interface_info.size_cmd = pc_packet_ul.datasize;
/*
						interface_info.pdata_dlbuff = buff_outtotal;
						interface_info.size_dlbuff = sizeof(buff_outtotal);
						*/
						PCSYN_new(interface_info.pdata_dlbuff,32000);
						if(interface_info.pdata_dlbuff ==0)
							return PC_Error_MemoryAlloc;
						interface_info.size_dlbuff = 32000;
						
						interface_info.pdata_ulbuff =0;
						interface_info.size_ulbuff =0;
						status = pc_interface(&interface_info);

						/*talcon add 2004/07/16*/
						buff_outtotal = interface_info.pdata_dlbuff;
						size_buff_outtotal = interface_info.size_dlbuff;
						
 						switch( status )
						{
							case PC_Error_WaitData:
								status = PC_Error_WaitData;
							case PC_Error_NoError:
								pc_protocol.status  = PC_CMDRECV;
								transfer_buff_outtotal = 0; 
								break;
							default:	//不支持的请求
								break;
 						}
						break;
					default:
						return PC_Error_InvalidFrameType;
				}
				break;
			case PC_CF_DataEnd:
				switch(pc_protocol.status)
				{
					case PC_DATAUL:
						pc_protocol.status = PC_CONNECTED;
						
						interface_info.flag = PC_IF_FLAGS_DATAUL;
						interface_info.pdata_cmd = 0;
						interface_info.pdata_dlbuff = 0;
						interface_info.pdata_ulbuff = buff_intotal;
						interface_info.size_ulbuff = size_buff_intotal;
						status = pc_interface(&interface_info);
						/*free memory*/
						PCSYN_free(buff_intotal, size_buff_intotal);
						buff_intotal = 0;
						size_buff_intotal = 0;
						//status = pc_readbuffer(buff_intotal,size_buff_intotal ,1)		;
						//pcsyndebug("dara rx end\n",strlen("dara rx end\n"));
						break;
					default:
						return PC_Error_InvalidFrameType;
				}
				break;
			case PC_CF_DisConnect:
				pc_disconnect();
				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_ul.frametype& 0x3f)
		{
		case PC_IF_Data:
			switch(pc_protocol.status)
			{
				case PC_CMDRECV:
					if(interface_info.flag == PC_IF_FLAGS_DATAUL)
					{
						pc_protocol.status = PC_DATAUL;
						//pc_protocol.frameid = PC_FRAME_MIN - 1;
						size_buff_intotal = 0;
						status = pc_uldata();
					}
					else if(interface_info.flag == PC_IF_FLAGS_DATADL)
					{
						pc_protocol.status = PC_DATADL;
						//status = pc_dldata();
					}
					break;
				case PC_DATAUL:
					status = pc_uldata();
					break;
				case PC_DATADL:
					//status = pc_dldata();
					break;
				default:
					status = PC_Error_InvalidFrameType;
					break;
			}
		       break;
		
		default:
			status = PC_Error_InvalidFrameType;
			break;
		}

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

	//send status to mmi
	if(pc_packet_ul.frametype == (PC_FT_Control | PC_CF_Cmd ) )/* 0x51 */
	{
		T_PCSYN_MMI_STATUS_IND parameter;
		parameter.controlid = frametype2;
		parameter.cid1 = interface_info.pdata_cmd[0];
		parameter.cid2 = interface_info.pdata_cmd[1];
		P_PCSYN_MMI_STATUS_IND(&parameter);
	}
	return status;
}