gprs_program.c

simcom100 GPRS 模块源程序

					cg_Decode = '&';
				}
				else if(cg_GprsTraBuff[cg_GprsTraCount] == 26)
				{
					if(cg_GprsTraCount == cg_GprsTraBuff[0])
					{
						SBUF = cg_GprsTraBuff[cg_GprsTraCount];
					}
					else
					{
						SBUF = '&';
						bg_Decode = 1;
						cg_Decode = 'A';
					}
				}
				else
				{
					SBUF = cg_GprsTraBuff[cg_GprsTraCount];
				}
			}
			else
			{
				SBUF = cg_GprsTraBuff[cg_GprsTraCount];
			}

		}
		else
		{
			cg_ExtInter &= GPRS_GREEN_OFF;
    		EXT_INTER = cg_ExtInter;
			bg_GprsTraFinish = 0;
			cg_GprsTraBuff[0] = 0;
			cg_GprsTraCount = 0;
		}
	}
} 

void Timer2(void) interrupt 5
{
}

/*
********************************************************************************************
*
*	GPRS启动，完成设置以及建立连接
*
********************************************************************************************
*/
uchar GprsStartUp()
{
	bit bg_GprsOk;
	uchar i;
    uchar cl_Buff;
	
	
	bg_GprsOk = 0;
	i = 0;
	while(!bg_GprsOk)
	{
		i ++;
		bg_GprsRst = 1;          //gprs  开始复位
		GprsRst = 1;
		delay(10);
		GprsRst = 0;             
	
		cg_GprsRecBuff[0] = 0;   //初始化
		cg_GprsTraBuff[0] = 0;
		cg_GprsRecDataBuff[0] = 0;
		cg_GprsErrorCount = 0;
		bg_GprsRec = 0;
		bg_GprsRecSE = 0;
		bg_GprsCr = 0;
		bg_GprsRxData = 0;
		bg_DispPeople = 0;
		bg_GprsRxComm = 1;
		
		bg_DataTxGprs = 0;      // 没有信息向gprs发送
		TimeCount = 0;
		while(!bg_GprsRec)
		{
			if(TimeCount > 100)
			{
				bg_GprsRxComm = 0;
				return 0x55;  //连接失败
			}
		}
	
		bg_GprsRec = 0;
		bg_GprsRxComm = 0;
		if((cg_GprsRecBuff[1] == 'R') && (cg_GprsRecBuff[2] == 'D') &&
			(cg_GprsRecBuff[3] == 'Y'))
		{
			bg_GprsOk = 1;
		}
	
		else 
		{
			//Gprs not ready 
			bg_GprsOk = 0;
		}
		if( i > 20) 
		{
        	return 0x55;
		}
	}
	TimeCount = 0;
	while(TimeCount < 14);         //wait 12s
	bg_GprsRst = 0;                //Gprs 复位结束
	bg_GprsRedFlash = 1;
	cl_Buff = GprsEcho();
	
	
	cg_GprsRecBuff[0] = 0;   //初始化
	cg_GprsTraBuff[0] = 0;
	cg_GprsRecDataBuff[0] = 0;
	cg_GprsErrorCount = 0;
	bg_GprsRec = 0;
	bg_GprsRecSE = 0;
	bg_GprsCr = 0;
	bg_GprsRxData = 0;
	bg_DispPeople = 0;
	bg_GprsRxComm = 1;
	bg_GprsDataHead = 0;
	bg_GprsRxHead = 0;
	bg_DataTxGprs = 0;      // 没有信息向gprs发送
	
	i = 0;
	do
	{

		cl_Buff = GprsConnect(&cg_IpAddr[0],&cg_Port[0]);
		if(cl_Buff != 0)
		{
			//连接不成功
			delay(2);
			i++;
		}
	
	}while((cl_Buff!=0) && (i<10));
	bg_GprsRedFlash = 0;
}

/*
**************************************************************************************************************
*
*	gprs发送处理
*
**************************************************************************************************************
*/
void GprsTxDeal(ComId)
{
	uchar cl_Buff;
	
	S_GPRS_TX *pGprsTx = (S_GPRS_TX *)&cg_GprsTx[0];
	
	pGprsTx->ComId = ComId;
	
	//save ComId, to repeat Tx
	cg_GprsComId = ComId;
	pGprsTx->Status = 0x00;
	if(bg_GprsRepeat)
	{
		bg_GprsRepeat = 0;
		pGprsTx->Serial = cg_GprsTxSerial;
	}
	else
	{
		pGprsTx->Serial ++;
		cg_GprsTxSerial = pGprsTx->Serial;
	}
	pGprsTx->TerminalNo = GPRS_SELF_ID;
	switch(pGprsTx->ComId)
	{
		case GPRS_CHECK:
					GprsCheck(pGprsTx);
					bg_GprsOverFlag = 1;
					cg_GprsOverCount = 0;
					break;
		case Q_GPRS_REPORT_R:
					GprsReport(pGprsTx);
					break;
		case GPRS_REPORT:
					GprsReport(pGprsTx);
					bg_GprsOverFlag = 1;
					cg_GprsOverCount = 0;
					break;
		case GPRS_COLLECT_REPORT:
					Q_GprsCollectDataR(pGprsTx);
					bg_GprsOverFlag = 1;
					cg_GprsOverCount = 0;
					cg_GprsTxTimeCount = 0;
					break;
		case Q_GPRS_COLLECT_REPORT_R:
					Q_GprsCollectDataR(pGprsTx);
					break;
		case GPRS_GPS_POSITION:
					GpsPosition(pGprsTx);
								
					break;
		default:
					break;
		
	}
	
	cl_Buff = GprsSendData(cg_GprsTx);            //发送数据
	cg_GprsTx[0] = 0;                             //
}
/*
*******************************************************************************************************************
*
*	发送GPS位置信息
*
*******************************************************************************************************************
*/
void GpsPosition(S_GPRS_TX *pGprsTx)
{
	uchar i;
	uchar *pc_GprsTx;
	uchar *pc_GprsTxBuff;
	
	pc_GprsTx = &cg_GprsTx[sizeof(S_GPRS_TX)];
	pc_GprsTxBuff = (uchar *)&sg_GprsReport;
	
	for(i=0; i<sizeof(S_GPRS_COLLECT_REPORT); i++)
	{
		pc_GprsTx[i] = pc_GprsTxBuff[i];
	}
	
	pGprsTx->Len = sizeof(S_GPRS_TX) + sizeof(S_GPRS_COLLECT_REPORT);
	VerifyDeal(cg_GprsTx);        //对gprs数据加校验处理 
}
	
/*
*******************************************************************************************************************
*
*	发送gprs维护命令
*
*******************************************************************************************************************
*/
void GprsCheck(S_GPRS_TX *pGprsTx)
{
	pGprsTx->Len = sizeof(S_GPRS_TX);
	
	VerifyDeal(cg_GprsTx);        //对gprs数据加校验处理
}

/*
*********************************************************************************************************************
*
*	发送报告当前信息命令
*
*********************************************************************************************************************
*/
void GprsReport(S_GPRS_TX *pGprsTx)
{
	uchar i;
	uchar *pc_GprsTx;
	uchar *pc_GprsTxBuff;
	
	pc_GprsTx = &cg_GprsTx[sizeof(S_GPRS_TX)];
	pc_GprsTxBuff = (uchar *)&sg_GprsReport;
	
	for(i=0; i<sizeof(S_GPRS_COLLECT_REPORT); i++)
	{
		pc_GprsTx[i] = pc_GprsTxBuff[i];
	}
	
	pGprsTx->Len = sizeof(S_GPRS_TX) + sizeof(S_GPRS_COLLECT_REPORT);
	VerifyDeal(cg_GprsTx);        //对gprs数据加校验处理
}

/*
********************************************************************************************************************
*
*	回复gprs收集信息的命令，上报以前保存在flash中的数据
*
********************************************************************************************************************
*/
void Q_GprsCollectDataR(S_GPRS_TX *pGprsTx)
{
	uchar i;
	uchar *pc_GprsTx;
	uchar *pc_GprsTxBuff;
	if(bg_CanNull)
	{
		pGprsTx->Len = sizeof(S_GPRS_TX);       //can接收数据为空时，发送空数据包
	}
	else
	{
		pc_GprsTx = &cg_GprsTx[sizeof(S_GPRS_TX)];
		pc_GprsTxBuff = (uchar *)&sg_GprsCollectReport;
		
		for(i=0; i<sizeof(S_GPRS_COLLECT_REPORT); i++)
		{
			pc_GprsTx[i] = pc_GprsTxBuff[i];
		}
		
		pGprsTx->Len = sizeof(S_GPRS_TX) + sizeof(S_GPRS_COLLECT_REPORT);
	}
	VerifyDeal(cg_GprsTx);        //对gprs数据加校验处理
	//if((sg_GprsCollectReport.PassengerStat.In == 0) ||
	//	(sg_GprsCollectReport.PassengerStat.Out == 0))
	//{
	//	sg_GprsCollectReport.PassengerStat.In = 1;
	//}	 
}
/*
********************************************************************************************************************
*
*	gprs接收处理
*
********************************************************************************************************************
*/
void GprsRxDeal(void)
{
	S_GPRS_RX *pGprsRx;
	uchar cl_Match;
	
	pGprsRx = (S_GPRS_RX *)&cg_GprsRecDataBuff[1];

	cl_Match = VerifyCheck(cg_GprsRecDataBuff);
	if( cl_Match != 0  )
	{
		//发送数据有错，重新发送
		cg_GprsOverCount = GPRS_OVER_TIME + 1;

		return;                //校验错误
	}
	
	if((pGprsRx->Status == GPRS_COMMAND_STATUS_ERR_CHECK) ||
		(pGprsRx->Status == GPRS_COMMAND_STATUS_ERR_OTHER))
	{
		//发送数据有错，重新发送
		cg_GprsOverCount = GPRS_OVER_TIME + 1;
		return;
	}
	switch(pGprsRx->ComId)
	{
		case GPRS_CHECK_R:
					if(cg_GprsOverCount < GPRS_OVER_TIME)
					{
						bg_GprsOverFlag = 0;
						cg_GprsOverCount = 0;
					}
					break;
		case GPRS_REPORT_R:
					if(cg_GprsOverCount < GPRS_OVER_TIME)
					{
						bg_GprsOverFlag = 0;
						cg_GprsOverCount = 0;
					}
					break;
		case Q_GPRS_REPORT:
					GprsTxDeal(Q_GPRS_REPORT_R);
					bg_GprsOverFlag = 1;
					cg_GprsOverCount = 0;
					break;
		case Q_GPRS_COLLECT_REPORT:
					//收到请求上报储存信息的命令
					//给客流采集模块发命令，请求传送储存信息
					GprsTxDeal(Q_GPRS_COLLECT_REPORT_R);
					break;
		case GPRS_COLLECT_REPORT_R:
					//gprs 已收到上次发送的数据记录，可以发送下一次
					//给客流采集模块发命令，请求传送储存信息
					 //如果上次接收的数据为非空时，继续接收，否则，停止
					if(pGprsRx->Serial == cg_GprsTxSerial)
					{
						bg_GprsOverFlag = 0;
						cg_GprsOverCount = 0;
						if(!bg_GprsRxFirst)
						{
							bg_GprsRxFirst = 1;					 
							if(cg_DoorKind == DOOR_F)
							{
								CanTxDeal(NEXT_COLLECT_REPORT,DOOR_F);
							}
						
							else if(cg_DoorKind == DOOR_H)
							{
								CanTxDeal(NEXT_COLLECT_REPORT,DOOR_H);
							}
						}
					}
					
					break;
		
		default:
					break;
	}
	
}

/*
*************************************************************************************************************
*
*	校验处理
*
*************************************************************************************************************
*/
void VerifyDeal(uchar *DataQuene)
{
	uchar i;
	uchar cl_Buff;
	DataQuene[0] ++;          //长度加1
	cl_Buff = DataQuene[0];
	
	for(i=1; i<(DataQuene[0]-1); i++)
	{
		cl_Buff = cl_Buff^DataQuene[i];
	}
	
	DataQuene[DataQuene[0]-1] = cl_Buff;
}

uchar VerifyCheck(uchar *DataQuene)
{
	uchar i;
	uchar cl_Match;

	cl_Match = (*DataQuene);
	for(i=1; i<(*DataQuene); i++)
	{
	 	cl_Match = cl_Match ^ DataQuene[i];
	}
	return (cl_Match);
}	


/*
**************************************************************************************
*
*	26-----拆分为'\'+ 'A'
*	**********************************************************************************	
*/