gsm.c

C语言编写的监控中心终端程序。基于GPRS上传收发数据功能

	if (GSMDelayTimer == 0) {
	    GSMLeaveState = 0x01;
	}
	break;

    case STATE_OK:
	GSMLeaveState = STATE_IDLE;	return OK;
	break;
    case STATE_ERROR:
	GSMLeaveState = STATE_IDLE;	return ERROR;
	break;
    }

    return IDLE;
}

/************************************************************************
 *  GSM Renet								*
 *	Renet process to the GSM module					*
 ************************************************************************/
BYTE GSMProcRenet(void)
{
    switch (GSMRenetState) {
    case STATE_IDLE:
	GSMRetryCount = 3;
	GSMRenetState++;
	break;
    case 0x01:
	GSMSendCommType	= ATO;
	GSMRenetState++;
	break;
    case 0x02:
	GSMFuncReturn = GSMProcSendComm();
	if (GSMFuncReturn != IDLE) {
	    if (GSMFuncReturn == CONNECT)	GSMRenetState++;
	    else				GSMRenetState = 0x90;
	}
	break;
    case 0x03:
	GSMDelayTimer = TIMER_xS(1);
	GSMRenetState++;
	break;
    case 0x04:
	if (GSMDelayTimer == 0)			GSMRenetState = STATE_OK;
	break;

    case 0x90:
	GSMRetryCount--;
	if (GSMRetryCount)			GSMRenetState++;
	else					GSMRenetState = STATE_ERROR;
	break;
    case 0x91:
	GSMDelayTimer = TIMER_xS(1);
	GSMRenetState++;
	break;
    case 0x92:
	if (GSMDelayTimer == 0)			GSMRenetState = 0x01;
	break;

    case STATE_OK:
	GSMRenetState = STATE_IDLE;	return OK;
	break;
    case STATE_ERROR:
	GSMRenetState = STATE_IDLE;	return ERROR;
	break;
    }

    return IDLE;
}

/************************************************************************
 *  GSM Close								*
 *	Close process to the GSM module					*
 ************************************************************************/
BYTE GSMProcClose(void)
{
    switch (GSMCloseState) {
    case STATE_IDLE:
	GSMRetryCount = 3;
	GSMCloseState++;
	break;
    case 0x01:
	GSMSendCommType	= ATmE2IPC;
	GSMCloseState++;
	break;
    case 0x02:
	GSMFuncReturn = GSMProcSendComm();
	if (GSMFuncReturn != IDLE) {
	    if (GSMFuncReturn == OK)		GSMCloseState++;
	    else				GSMCloseState = 0x90;
	}
	break;
    case 0x03:
	GSMCloseState = STATE_OK;
	break;

    case 0x90:
	GSMRetryCount--;
	if (GSMRetryCount)			GSMCloseState++;
	else					GSMCloseState = STATE_ERROR;
	break;
    case 0x91:
	GSMDelayTimer = TIMER_xS(1);
	GSMCloseState++;
	break;
    case 0x92:
	if (GSMDelayTimer == 0) {
	    GSMCloseState = 0x01;
	}
	break;

    case STATE_OK:
	GSMCloseState = STATE_IDLE;	return OK;
	break;
    case STATE_ERROR:
	GSMCloseState = STATE_IDLE;	return ERROR;
	break;
    }

    return IDLE;
}

/************************************************************************
 *  GSM Clear								*
 *	Clear process to the GSM module					*
 ************************************************************************/
BYTE GSMProcClear(void)
{
    switch (GSMClearState) {
    case STATE_IDLE:
	GSMRetryCount = 3;
	GSMClearState++;
	break;
    case 0x01:
	GSMSendCommType	= ATmE2IPA0;
	GSMSendCommPara	= CGDCountIndex;
	GSMClearState++;
	break;
    case 0x02:
	GSMFuncReturn = GSMProcSendComm();
	if (GSMFuncReturn != IDLE) {
	    if (GSMFuncReturn == OK)		GSMClearState++;
	    else				GSMClearState = 0x90;
	}
	break;
    case 0x03:
	GSMClearState = STATE_OK;
	break;

    case 0x90:
	GSMRetryCount--;
	if (GSMRetryCount)			GSMClearState++;
	else					GSMClearState = STATE_ERROR;
	break;
    case 0x91:
	GSMDelayTimer = TIMER_xS(1);
	GSMClearState++;
	break;
    case 0x92:
	if (GSMDelayTimer == 0) {
	    GSMClearState = 0x01;
	}
	break;

    case STATE_OK:
	GSMClearState = STATE_IDLE;	return OK;
	break;
    case STATE_ERROR:
	GSMClearState = STATE_IDLE;	return ERROR;
	break;
    }

    return IDLE;
}

/************************************************************************
 *  GSM Phone								*
 *	Phone process to the GSM module					*
 ************************************************************************/
BYTE GSMProcPhone(void)
{
    switch (GSMPhoneState) {
    case STATE_IDLE:
	GSMPhoneState++;
	break;
    case 0x01:
	GSMSendCommType	= ATA;
	GSMPhoneState++;
	break;
    case 0x02:
	GSMFuncReturn = GSMProcSendComm();
	if (GSMFuncReturn != IDLE) {
	    if (GSMFuncReturn == OK)		GSMPhoneState++;
	    else				GSMPhoneState = 0x80;
	}
	break;
    case 0x03:
	GSMPhoneReady = FALSE;
	GSMPhoneTimer = TIMER_xS(5);
	GSMPhoneState++;
	break;
    case 0x04:
#ifdef	WAVECOM
	if (GSMWaitPhoneReply() == NOCARRIER) {
	    GSMPhoneState = STATE_OK;
	}
#else
	if (GSMProcReadComm() == ECAV && GSMPhoneValue == 0) {	// Hung-Up
	    GSMPhoneState = STATE_OK;
	}
#endif
	else
	if (GSMPhoneTooth) {
	    GSMPhoneTooth = FALSE;
	    GSMPhoneState = 0x80;
	}
	else
	if (GSMPhoneTimer == 0) {
	    GSMPhoneState++;
	}
	break;
    case 0x05:
	GSMSendCommType	= ATpCPAS;
	GSMPhoneState++;
	break;
    case 0x06:
	GSMFuncReturn = GSMProcSendComm();
	if (GSMFuncReturn != IDLE) {
	    if (GSMFuncReturn == OK)		GSMPhoneState++;
	    else				GSMPhoneState = 0x80;
	}
	break;
    case 0x07:
	if (GSMPhoneReady)			GSMPhoneState = STATE_OK;
	else					GSMPhoneState = 0x03;
	break;

    case 0x80:
	GSMSendCommType	= ATH;
	GSMPhoneState++;
	break;
    case 0x81:
	GSMFuncReturn = GSMProcSendComm();
	if (GSMFuncReturn != IDLE) {
	    if (GSMFuncReturn == OK)		GSMPhoneState++;
	    else				GSMPhoneState = STATE_ERROR;
	}
	break;
    case 0x82:
	GSMPhoneState = STATE_OK;
	break;

    case STATE_OK:
	GSMPhonePhase = GSM_PHONE_HANG;
	if (GSMRadioState) {
	    GSMRadioState = RADIO_OK;
	}
	GSMPhoneState = STATE_IDLE;		return OK;
	break;
    case STATE_ERROR:
	GSMPhonePhase = GSM_PHONE_HANG;
	if (GSMRadioState) {
	    GSMRadioState = RADIO_OK;
	}
	GSMPhoneState = STATE_IDLE;		return ERROR;
	break;
    }

    return IDLE;
}

/************************************************************************
 *  GSM Read SMS							*
 *	Read SMS from the GSM module					*
 ************************************************************************/
BYTE GSMProcReadSMS(void)
{
    switch (SMSReadState) {
    case STATE_IDLE:
	SMSReadState++;
	break;
    case 0x01:
	GSMSendCommType	= ATpCMGFe1;
	SMSReadState++;
	break;
    case 0x03:
	GSMSendCommType	= ATpCMGR;
	GSMSendCommPara	= SMSReadIndex;
	SMSReadState++;
	break;
    case 0x05:
	GSMSendCommType	= ATpCMGD;
	GSMSendCommPara	= SMSReadIndex;
	SMSReadState++;
	break;
    case 0x02:
    case 0x04:
    case 0x06:
	GSMFuncReturn = GSMProcSendComm();
	if (GSMFuncReturn != IDLE) {
	    if (GSMFuncReturn == OK)		SMSReadState++;
	    else				SMSReadState = STATE_ERROR;
	}
	break;

    case 0x07:
	SMSReadState = STATE_OK;
	break;

    case STATE_OK:
	SMSReadState = STATE_IDLE;
	return OK;
	break;
    case STATE_ERROR:
	SMSReadState = STATE_IDLE;
	return ERROR;
	break;
    }

    return IDLE;
}

/************************************************************************
 *  GSM Send SMS Head							*
 *	Sead SMS Head to the GSM module					*
 ************************************************************************/
BYTE GSMProcSendSMSHead(void)
{
    switch (SMSHeadState) {
    case STATE_IDLE:
	SMSHeadState++;
	break;
    case 0x01:
	GSMFuncReturn = GSMProcSendComm();
	if (GSMFuncReturn != IDLE) {
	    if (GSMFuncReturn == CMGS)		SMSHeadState++;
	    else				SMSHeadState = STATE_ERROR;
	}
	break;
    case 0x02:
	 strcpy(GSMSendBuff, cStrSMSCenterHead);	GSMSendSize  = LenSMSCenterHead;
	 strcpy(GSMSendCurr, cStrSMSMobileHead);	GSMSendSize += LenSMSMobileHead;
	 strcpy(GSMSendCurr,  StrSMSHeaderPDU);		GSMSendSize += strlen(StrSMSHeaderPDU);
	 strcpy(GSMSendCurr, cStrSMSMobileTail);	GSMSendSize += LenSMSMobileTail;
	Hex2Str(GSMSendCurr,  GSMSendCommPara -
			      LenSMSInfoHead / 2);	GSMSendSize += 2;
	SMSHeadState = STATE_OK;
	break;

    case STATE_OK:
	SMSHeadState = STATE_IDLE;		return OK;
	break;
    case STATE_ERROR:
	SMSHeadState = STATE_IDLE;		return ERROR;
	break;
    }

    return IDLE;
}

/************************************************************************
 *  GSM Send SMS Tail							*
 *	Sead SMS Tail to the GSM module					*
 ************************************************************************/
BYTE GSMProcSendSMSTail(void)
{
    switch (SMSTailState) {
    case STATE_IDLE:
	GSMDelayTimer = TIMER_xS(120);
	SMSTailState++;
	break;
    case 0x01:
	GSMFuncReturn = GSMWaitSendSMSEnd();
	if (GSMFuncReturn != IDLE) {
	    GSMProcModemReply();
	    if (GSMFuncReturn == OK)		SMSTailState = STATE_OK;
	    else				SMSTailState = STATE_ERROR;
	}
	else if (GSMDelayTimer == 0)		SMSTailState = STATE_TIMEOUT;
	break;

    case STATE_OK:
#ifdef SUPPORT_USART_SHOW
	psprintf(LineBuffer, "OK,");
	DBusEditShowText(LineBuffer);
#endif
	SMSTailState = STATE_IDLE;		return OK;
	break;
    case STATE_ERROR:
#ifdef SUPPORT_USART_SHOW
	psprintf(LineBuffer, "ERROR,");
	DBusEditShowText(LineBuffer);
#endif
	SMSTailState = STATE_IDLE;		return ERROR;
	break;
    case STATE_TIMEOUT:
#ifdef SUPPORT_USART_SHOW
	psprintf(LineBuffer, "SMS-TimeOut,");
	DBusEditShowText(LineBuffer);
#endif
	InitReadBuff();
	InitSendBuff();
	SMSTailState = STATE_IDLE;		return TIMEOUT;
	break;
    }

    return IDLE;
}

/************************************************************************
 *	GSM Make Data							*
 ************************************************************************/
void GSMMakeSendSMS()
{
    strcpylen(StrSMSInfoName,  DBusDBusIDStr,	MaxSMSInfoName);
    strcpylen(StrSMSHeaderTXT, DBusSMSCNum,	MaxSMSMobileTXT);
    Txt2Pdu(StrSMSHeaderPDU, StrSMSHeaderTXT);
    LenSMSInfoHead = LenSMSMobileHead + strlen(StrSMSHeaderPDU) + LenSMSMobileTail + 2;

    psprintf(StrSMSInfoTime,	"%02d:%02d:%02d",	DBusGPSInfoTimeHH,
							DBusGPSInfoTimeMM,
							DBusGPSInfoTimeSS);
    psprintf(StrSMSInfoLang,	"%d.%02d.%02d",		DBusGPSInfoE / 100 / 3600 % 1000,
							DBusGPSInfoE / 100 / 60 % 60,
							DBusGPSInfoE / 100 % 60);
    psprintf(StrSMSInfoLat,	"%d.%02d.%02d",		DBusGPSInfoN / 100 / 3600 % 1000,
							DBusGPSInfoN / 100 / 60 % 60,
							DBusGPSInfoN / 100 % 60);
    psprintf(StrSMSInfoSpeed,	"%d",			DBusGPSInfoSpeed % 1000);
    psprintf(StrSMSInfoAngle,	"%d",			DBusGPSInfoAngle % 360);

    StrToPDUText(StrSMSInfoPosi, DBusGPSPosiText);

#ifdef SUPPORT_TAXI_FUNCTION
    if (ACCSwitchOn)		Str2Unc(StrSMSInfoRun,  StrSMSInfoSpeed);
    else			strcpy( StrSMSInfoRun, cStrSMSSpeedStop);
#else
				Str2Unc(StrSMSInfoRun,  StrSMSInfoSpeed);
#endif
}

/************************************************************************
 *  GSM Send SMS							*
 *	Sead SMS to the GSM module					*
 ************************************************************************/
BYTE GSMProcSendSMS(void)
{
    switch (SMSSendState) {
    case STATE_IDLE:
	if (FIFO_SEND_EMPTY) {
	    SMSSendState = STATE_OK;
	}
	else {
	    FIFO_SEND_FC(SMSSendInfo);
	    SMSSendInfoHost = SMSSendInfo >> 8;
	    SMSSendInfoType = SMSSendInfo & 0xFF;
	    if (SMSSendInfoHost >= MOBILE_COUNT || SMSSendInfoType >= SMS_TYPE_COUNT) {
		FIFO_SEND_FF;
		SMSSendState = STATE_OK;
	    }
	    else {
		GSMMakeSendSMS();
		SMSSendState++;
	    }
	}
	break;
    case 0x01:
	GSMSendCommType	= ATpCMGFe0;
	SMSSendState++;
	break;
    case 0x02:
	GSMFuncReturn = GSMProcSendComm();
	if (GSMFuncReturn != IDLE) {
	    if (GSMFuncReturn == OK)	SMSSendState++;
	    else			SMSSendState = STATE_ERROR;
	}
	break;
    case 0x03:
	switch (SMSSendInfoType) {
	case SMS_GRD_INIT:
	case SMS_GRD_HAVE:
	case SMS_GRD_LOCK:
	case SMS_GRD_UNLOCK:
	case SMS_GRD_ALARM:
	case SMS_GRD_WARN_TOUCH:
	case SMS_GRD_WARN_DOOR:
	case SMS_GRD_WARN_ACC:
	case SMS_GRD_WARN_ALARM:
	case SMS_GRD_WARN_HELP:		SMSSendState = 0x40;		break;
	default:	FIFO_SEND_FF;	SMSSendState = STATE_OK;	break;
	}
	break;