gsm.c

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

    case 0x40:
	GSMSendCommType	= ATpCMGS;
	GSMSendCommPara	= (LenSMSInfoHead			+
			   LenSMSInfoName	+ LenSMSNewLine +
			   LenSMSInfoTime	+ LenSMSNewLine +
			   LenSMSInfoLang	+ LenSMSNewLine +
			   LenSMSInfoLat	+ LenSMSNewLine +
			   LenSMSInfoRun	+ LenSMSNewLine +
			   LenSMSInfoGuard	+ LenSMSNewLine +
			   LenSMSInfoPosi) / 2;
	SMSSendState++;
	break;
    case 0x41:
	GSMFuncReturn = GSMProcSendSMSHead();
	if (GSMFuncReturn != IDLE) {
	    if (GSMFuncReturn == OK)		SMSSendState++;
	    else				SMSSendState = 0xF9;
	}
	break;
    case 0x43:
	Str2Unc(GSMSendBuff,  StrSMSInfoName);		GSMSendSize  = LenSMSInfoName;
	 strcpy(GSMSendCurr, cStrSMSSplitOr);		GSMSendSize += LenSMSNewLine;
	Str2Unc(GSMSendCurr,  StrSMSInfoTime);		GSMSendSize += LenSMSInfoTime;
	 strcpy(GSMSendCurr, cStrSMSSplitOr);		GSMSendSize += LenSMSNewLine;
	Str2Unc(GSMSendCurr,  StrSMSInfoLang);		GSMSendSize += LenSMSInfoLang;
	 strcpy(GSMSendCurr, cStrSMSSplitOr);		GSMSendSize += LenSMSNewLine;
	SMSSendState++;
	break;
    case 0x45:
	Str2Unc(GSMSendBuff,  StrSMSInfoLat);		GSMSendSize += LenSMSInfoLat;
	 strcpy(GSMSendCurr, cStrSMSSplitOr);		GSMSendSize += LenSMSNewLine;
	 strcpy(GSMSendCurr,  StrSMSInfoRun);		GSMSendSize += LenSMSInfoRun;
	 strcpy(GSMSendCurr, cStrSMSSplitOr);		GSMSendSize += LenSMSNewLine;
	 strcpy(GSMSendCurr, cStrSMSInfoGuard[SMSSendInfoType - SMS_GRD_INIT]);
							GSMSendSize += LenSMSInfoGuard;
	 strcpy(GSMSendCurr, cStrSMSSplitOr);		GSMSendSize += LenSMSNewLine;
	SMSSendState++;
	break;
    case 0x47:
	 strcpy(GSMSendBuff,  StrSMSInfoPosi);		GSMSendSize  = LenSMSInfoPosi;
	 strcpy(GSMSendCurr, cStrSMSInfoTail);		GSMSendSize += LenSMSInfoTail;
	SMSSendState++;
	break;
    case 0x42:
    case 0x44:
    case 0x46:
    case 0x48:
	GSMFuncReturn = GSMProcSendData();
	if (GSMFuncReturn != IDLE) {
	    if (GSMFuncReturn == OK)		SMSSendState++;
	    else				SMSSendState = 0xF9;
	}
	break;
    case 0x49:
	GSMFuncReturn = GSMProcSendSMSTail();
	if (GSMFuncReturn == OK) {
	    FIFO_SEND_FF;			SMSSendState = STATE_OK;
	}
	else if (GSMFuncReturn == ERROR)	SMSSendState = STATE_ERROR;
	else if (GSMFuncReturn == TIMEOUT)	SMSSendState = 0xF9;
	break;

    case 0xF9:
	GSMSendCommType	= CTRL_Z;
	SMSSendState++;
	break;
    case 0xFA:
	GSMFuncReturn = GSMProcSendComm();
	if (GSMFuncReturn != IDLE) {
	    SMSSendState = STATE_ERROR;
	}
	break;

    case STATE_OK:
	SMSSendRetry = 5;
	SMSSendState = STATE_IDLE;			return OK;
	break;
    case STATE_ERROR:
	SMSSendRetry--;
#ifdef SUPPORT_USART_SHOW
	psprintf(LineBuffer, "%d,", SMSSendRetry);
	DBusEditShowText(LineBuffer);
#endif
	if (SMSSendRetry == 0) {
	    SMSSendRetry = 5;
	    FIFO_SEND_FF;
	}
	SMSSendState = STATE_IDLE;			return ERROR;
	break;
    }

    return IDLE;
}

/************************************************************************
 *  GSM Test CSQ							*
 *	Test CSQ of the GSM module					*
 ************************************************************************/
BYTE GSMProcTestCSQ(void)
{
    switch (GSMCheckState) {
    case STATE_IDLE:
	GSMDelayTimer = TIMER_xS(1);
	GSMCheckState++;
	break;
    case 0x01:
	GSMSendCommType	= ATpCSQ;
	GSMCheckState++;
	break;
    case 0x02:
	GSMFuncReturn = GSMProcSendComm();
	     if (GSMFuncReturn == OK)		GSMCheckState++;
	else if (GSMFuncReturn == ERROR)	GSMCheckState = STATE_ERROR;
	else if (GSMDelayTimer == 0)		GSMCheckState = STATE_ERROR;
	break;
    case 0x03:
	GSMCheckState = STATE_OK;
	break;

    case STATE_OK:
	GSMCheckError = 0;
	GSMCheckState = STATE_IDLE;			return OK;
	break;
    case STATE_ERROR:
	GSMCheckError++;
	GSMCheckState = STATE_IDLE;			return ERROR;
	break;
    }

    return IDLE;
}

/************************************************************************
 *  GSM Check RI							*
 *	Check RI Pin of the GSM module					*
 ************************************************************************/
#ifdef SUPPORT_TAXI_FUNCTION
BYTE GSMProcCheckRI()
{
    BYTE		ActualState;

    ActualState	= (GSM_RI_IN) ? FALSE : TRUE;

    if (ActualState == GSMPinRIState) {
	GSMPinRICount = 10;
    }
    else if (--GSMPinRICount == 0) {
	GSMPinRICount = 10;
	GSMPinRIState = ActualState;
	GSMRingGPRS   = GSMPinRIState;
	DBusShowGSMRingGPRS = TRUE;
	return (GSMPinRIState ? OK : ERROR);
    }

    return IDLE;
}
#endif

/************************************************************************
 *	GSM User Break							*
 ************************************************************************/
void GSMNoteBreakLink()
{
#if 0
    switch (GSMRoundState) {
    case GSM_HELLO_GPRS:
    case GSM_LEAVE_GPRS:
    case GSM_CLOSE_GPRS:
    case GSM_CLEAR_GPRS:
	break;
    case GSM_ENTER_GPRS:
    case GSM_RENET_GPRS:
    case GSM_STATE_GPRS:
	GSMBreakCount = 2;
	break;
    }
#else
    InitUserBuff();
//  GSMRoundState = GSM_POWER_PROC;
    GSMRoundState = GSM_SLEEP_PROC;
#endif
}

/************************************************************************
 *	GSM Send SMS							*
 ************************************************************************/
void GSMNoteSendBySMS(BYTE Type)
{
    switch (Type) {
    case COMM_GRD_INIT:		SMSGuardData = SMS_GRD_INIT;		break;
    case COMM_GRD_HAVE:		SMSGuardData = SMS_GRD_HAVE;		break;
    case COMM_GRD_LOCK:		SMSGuardData = SMS_GRD_LOCK;		break;
    case COMM_GRD_UNLOCK:	SMSGuardData = SMS_GRD_UNLOCK;		break;
    case COMM_GRD_ALARM:	SMSGuardData = SMS_GRD_ALARM;		break;
    case COMM_GRD_WARN_TOUCH:	SMSGuardData = SMS_GRD_WARN_TOUCH;	break;
    case COMM_GRD_WARN_DOOR:	SMSGuardData = SMS_GRD_WARN_DOOR;	break;
    case COMM_GRD_WARN_ACC:	SMSGuardData = SMS_GRD_WARN_ACC;	break;
    case COMM_GRD_WARN_ALARM:	SMSGuardData = SMS_GRD_WARN_ALARM;	break;
    default:			return;
    }

    SMSBlockState = TRUE;
}

/************************************************************************
 *	GSM Guard Data							*
 ************************************************************************/
void GSMNoteGuardData(BYTE Type)
{
    switch (Type) {
    case COMM_GRD_INIT:		SMSGuardWarn = SMS_GRD_INIT;		break;
    case COMM_GRD_HAVE:		SMSGuardWarn = SMS_GRD_HAVE;		break;
    case COMM_GRD_LOCK:		SMSGuardWarn = SMS_GRD_LOCK;		break;
    case COMM_GRD_UNLOCK:	SMSGuardWarn = SMS_GRD_UNLOCK;		break;
    case COMM_GRD_ALARM:	SMSGuardWarn = SMS_GRD_ALARM;		break;
    case COMM_GRD_WARN_TOUCH:	SMSGuardWarn = SMS_GRD_WARN_TOUCH;	break;
    case COMM_GRD_WARN_DOOR:	SMSGuardWarn = SMS_GRD_WARN_DOOR;	break;
    case COMM_GRD_WARN_ACC:	SMSGuardWarn = SMS_GRD_WARN_ACC;	break;
    case COMM_GRD_WARN_ALARM:	SMSGuardWarn = SMS_GRD_WARN_ALARM;	break;
    case COMM_GRD_WARN_HELP:	SMSGuardWarn = SMS_GRD_WARN_HELP;	break;
    default:			return;
    }

    SMSGuardState = TRUE;
}

/************************************************************************
 *	GSM Guard Wait							*
 ************************************************************************/
void GSMNoteGuardWait(BYTE Type)
{
    switch (Type) {
/*
    case COMM_GRD_LOCK_OK:	SMSGuardWarn = ;			break;
    case COMM_GRD_UNLOCK_OK:	SMSGuardWarn = ;			break;
    case COMM_GRD_ALARM_OK:	SMSGuardWarn = ;			break;
    case COMM_GRD_LOCK_FAIL:	SMSGuardWarn = ;			break;
    case COMM_GRD_UNLOCK_FAIL:	SMSGuardWarn = ;			break;
    case COMM_GRD_ALARM_FAIL:	SMSGuardWarn = ;			break;
    case COMM_GRD_LOCK_ERROR:	SMSGuardWarn = ;			break;
    case COMM_GRD_UNLOCK_ERROR:	SMSGuardWarn = ;			break;
    case COMM_GRD_ALARM_ERROR:	SMSGuardWarn = ;			break;
*/
    default:			return;
    }
}

/************************************************************************
 *	GSM Timer Base							*
 ************************************************************************/
void GSMTimer100mS()
{
    if (GSMDelayTimer)		GSMDelayTimer--;
    if (GSMSenseTimer)		GSMSenseTimer--;
    if (GSMCheckTimer)		GSMCheckTimer--;
    if (GSMBlockTimer)		GSMBlockTimer--;
    if (GSMPhoneTimer)		GSMPhoneTimer--;

    if (SMSEmptyTimer)		SMSEmptyTimer--;

#ifdef DEBUG_WITH_PC
    if (GSMDebugTimer)		GSMDebugTimer--;
#endif
}

/************************************************************************
 *	GSM Polling Code						*
 ************************************************************************/
void PollingGSM()
{
#ifdef MONITOR_HARDWARE_TEST
    static BYTE		Monitor[5];
	   BYTE		ReadPin[2];
#endif

    switch (GSMRoundState) {
    case GSM_SLEEP_PROC:
	GSMFuncReturn = GSMProcSleep();
	if (GSMFuncReturn == OK) {
	    GSMInitGPRS   = FALSE;
	    GSMRoundState = GSM_SLEEP_DONE;
	}
	break;

    case GSM_SLEEP_DONE:
//	GSMRoundState = GSM_RESET_PROC;
	GSMRoundState = GSM_POWER_PROC;
	break;

    case GSM_POWER_PROC:
	GSMFuncReturn = GSMProcPower();
	if (GSMFuncReturn == OK) {
	    GSMInitGPRS   = TRUE;
	    GSMRoundState = GSM_POWER_DONE;
	}
	else
	if (GSMFuncReturn == ERROR)
	    GSMRoundState = GSM_SLEEP_PROC;
	break;

    case GSM_POWER_DONE:
	GSMCheckTimer = TIMER_xS(5);
	GSMRoundState = GSM_STATE_IDLE;
	break;

    case GSM_RESET_PROC:
	GSMFuncReturn = GSMProcReset();
	if (GSMFuncReturn == OK)
	    GSMRoundState = GSM_POWER_DONE;
	else
	if (GSMFuncReturn == ERROR)
	    GSMRoundState = GSM_SLEEP_PROC;
	break;

    case GSM_STATE_IDLE:
#ifdef SUPPORT_TAXI_FUNCTION
	if (GSMPhonePhase == GSM_PHONE_RING) {
	    if (GSMPhoneTimer == 0) {
		GSMPhonePhase = GSM_PHONE_HANG;
		if (GSMRadioState) {
		    GSMRadioState = RADIO_OK;
		}
#ifdef SUPPORT_USART_SHOW
		DBusEditShowText("NO RING,");
#endif
	    }
	    else
	    if (GSMPhoneTooth) {
		GSMPhoneTooth = FALSE;
		GSMPhonePhase = GSM_PHONE_HEAR;
		GSMRoundState = GSM_PHONE_PROC;
	    }
	    else {
		GSMProcReadComm();
	    }
	}
	else
	if (GSMRadioState) {
	    if (GSMRadioState == RADIO_OK) {
		GSMRadioState =  RADIO_IDLE;
		GSMRoundState =  GSM_RENET_GPRS;
	    }
	    else {
		GSMProcReadComm();
	    }
	}
	else
#endif
	if (GSMBlockState && GSMBlockTimer == 0) {
	    GSMBlockState = FALSE;
	    GSMBlockTimer = GSM_BLOCK_INTERVAL;
	}
	else
	if (GSMCheckCount >= 24 || GSMCheckError >= 10) {
	    GSMCheckCount = 0;
	    GSMCheckError = 0;
	    GSMRoundState = GSM_SLEEP_PROC;
	}
#ifdef SUPPORT_TAXI_FUNCTION
	else
	if (!FIFO_SEND_EMPTY) {
	    GSMRoundState = GSM_SMSTO_SEND;
	}
	else
	if (!FIFO_READ_EMPTY) {
	    FIFO_READ_FO(SMSReadIndex);
	    GSMRoundState = GSM_SMSIN_READ;
	}
	else
	if (SMSBlockState) {
	    SMSBlockState = FALSE;
	    if (ACCSwitchOn) {
		FIFO_SEND_FI((MOBILE_HOSTER << 8) | SMSGuardData);
	    }
	}
	else
	if (SMSGuardState) {
	    SMSGuardState = FALSE;
	    if (SMSGuardWarn >= SMS_GRD_WARN_TOUCH) {
		FIFO_SEND_FI((MOBILE_HOSTER << 8) | SMSGuardWarn);
	    }
	}
#endif
	else
	if (GSMCheckTimer == 0)	{
	    GSMCheckTimer = TIMER_xS(5);
	    GSMRoundState = GSM_CHECK_PROC;
	}
#ifdef SUPPORT_TAXI_FUNCTION
	else
	if (SMSEmptyTimer == 0) {
	    SMSEmptyTimer = SMS_EMPTY_INTERVAL;
	    if (!FIFO_READ_FULL) {
		FIFO_READ_FI(SMSEmptyIndex);
		if (SMSEmptyIndex == SMSEmptyCount)	SMSEmptyIndex = 1;
		else					SMSEmptyIndex++;
	    }
	}
#endif
	else
	if (!GSMBlockState && GSMBlockTimer == 0) {
	    GSMRoundState = GSM_HELLO_GPRS;
	}
	else {
	    GSMProcReadComm();
	}
	break;

    case GSM_HELLO_GPRS:
	GSMFuncReturn = GSMProcHello();
	if (GSMFuncReturn == OK)
	    GSMRoundState = GSM_ENTER_GPRS;
	else
	if (GSMFuncReturn == ERROR) {
	    GSMErrorState = GSM_HELLO_GPRS;
	    GSMRoundState = GSM_ERROR_GPRS;
	}
	break;

    case GSM_ENTER_GPRS:
	GSMFuncReturn = GSMProcEnter();
	if (GSMFuncReturn == OK) {
	    GSMEnterCount = 2;
	    GSMBreakCount = 0;
	    GSMCenterFlag = FALSE;
	    GSMLinkGPRS	  = TRUE;
	    GSMRoundState = GSM_STATE_GPRS;
	}
	else
	if (GSMFuncReturn == ERROR) {
	    GSMErrorState = GSM_ENTER_GPRS;
	    GSMRoundState = GSM_ERROR_GPRS;
	}
	break;

    case GSM_LEAVE_GPRS:
	GSMFuncReturn = GSMProcLeave();
	if (GSMFuncReturn == OK) {
	    GSMEnterCount = 1;
	    if (GSMBreakCount == 0)	GSMRoundState = GSM_RENET_GPRS;
	    else if (--GSMBreakCount)	GSMRoundState = GSM_CLOSE_GPRS;
	    else			GSMRoundState = GSM_STATE_IDLE;
	}
	else
	if (GSMFuncReturn == ERROR) {
	    GSMErrorState = GSM_LEAVE_GPRS;
	    GSMRoundState = GSM_ERROR_GPRS;
	}
	break;

    case GSM_RENET_GPRS:
	GSMFuncReturn = GSMProcRenet();
	if (GSMFuncReturn == OK) {
	    GSMEnterCount = 2;
	    GSMBreakCount = 0;
	    GSMCenterFlag = FALSE;
	    GSMLinkGPRS	  = TRUE;
	    GSMRoundState = GSM_STATE_GPRS;
	}
	else
	if (GSMFuncReturn == ERROR) {
	    GSMErrorState = GSM_RENET_GPRS;
	    GSMRoundState = GSM_ERROR_GPRS;
	}
	break;

    case GSM_CLOSE_GPRS:
	GSMFuncReturn = GSMProcClose();
	if (GSMFuncReturn == OK) {
	    GSMEnterCount = 0;
	    GSMBreakCount = 0;
	    GSMRoundState = GSM_CLEAR_GPRS;
	}
	else
	if (GSMFuncReturn == ERROR) {
	    GSMErrorState = GSM_CLOSE_GPRS;
	    GSMRoundState = GSM_ERROR_GPRS;
	}
	break;

    case GSM_CLEAR_GPRS:
	GSMFuncReturn = GSMProcClear();
	if (GSMFuncReturn == OK) {
	    GSMEnterCount = 0;
	    GSMBreakCount = 0;
	    CGDCountIndex++;
	    if (CGDCountIndex > CGD_COUNT_MAX) {
		CGDCountIndex = 1;
	    }
	    if (