gsm.c

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

#ifdef SUPPORT_USART_SHOW
	    psprintf(LineBuffer, "OK,");
	    DBusEditShowText(LineBuffer);
#endif
	    return OK;
	}

	InitReadBuff();
    }

    return IDLE;
}

/************************************************************************
 *  GSM Wait Phone Reply						*
 *	Wait Phone Reply from the GSM Module				*
 ************************************************************************/
BYTE GSMWaitPhoneReply(void)
{
    if ((GSMReadUsart() == 0)		||
	(GSMReadSize < LenGSMNOCARRIER))
	return IDLE;

    strcpy(StrLineBuff, cStrGSMNOCARRIER);
    if ((PtrTempAddr = strstr(GSMReadBuff, StrLineBuff)) != NULL) {
	memcopy(PtrTempAddr, PtrTempAddr + LenGSMNOCARRIER,
		GSMReadSize - (PtrTempAddr - GSMReadBuff) - LenGSMNOCARRIER + 1);
	return NOCARRIER;
    }

    return IDLE;
}

/************************************************************************
 *  GSM Proc Read Data							*
 *	Proc Read Data's response					*
 ************************************************************************/
BYTE GSMWaitCenterData(void)
{
    UINT16		i;

    GSMReadUsart();
    if (GSMReadSize == 0)
	return IDLE;

    if (!GSMCenterFlag) {
	for (i = 0; (i + 1) < GSMReadSize; i++) {
	    if (GSMReadBuff[i] == 0x55 && GSMReadBuff[i + 1] == 0x7A) {
		GSMCenterFlag = TRUE;
		GSMCenterPos1 = i;
		break;
	    }
	}
    }

    if (GSMCenterFlag && (GSMReadSize - GSMCenterPos1) > 3) {
	if (GSMReadSize - GSMCenterPos1 >= GSMReadBuff[GSMCenterPos1 + 3] + 6) {
	    GSMCenterFlag = FALSE;
	    GSMCenterPos2 = GSMCenterPos1 + GSMReadBuff[GSMCenterPos1 + 3] + 6;

	    memcopy(DBusDataDnLoad,	GSMReadBuff   + GSMCenterPos1,
					GSMCenterPos2 - GSMCenterPos1);
	    memcopy(GSMReadBuff,	GSMReadBuff   + GSMCenterPos2,
					GSMReadSize   - GSMCenterPos2);
	    GSMReadSize -= GSMCenterPos2;
#ifdef SUPPORT_USART_SHOW
	    psprintf(LineBuffer, "CENTER,");
	    DBusEditShowText(LineBuffer);
#endif
	    return CENTER;
	}
    }

    return IDLE;
}

/************************************************************************
 *  GSM Wait Send SMS End						*
 *	Wait Send SMS End from the GSM Module				*
 ************************************************************************/
BYTE GSMWaitSendSMSEnd(void)
{
    UINT16		i;

    if ((GSMReadUsart() == 0)		||
	(GSMReadSize < 9))
	return IDLE;

    if ((PtrTempAddr = strstr(GSMReadBuff, "\x0D\x0A""+CMGS: ")) != NULL) {
	GSMReadAddr = PtrTempAddr - GSMReadBuff;

	for (i = GSMReadAddr + 9; i <= GSMReadSize; i++) {
	    if (GSMReadBuff[i - 2] == CR && GSMReadBuff[i - 1] == LF) {
		GSMReadStop = i;

		if (memcmp(GSMReadBuff + i - LenGSMOK, (BYTE *)cStrGSMOK, LenGSMOK) == 0) {
#ifdef SUPPORT_USART_SHOW
		    psprintf(LineBuffer, "OK,");
		    DBusEditShowText(LineBuffer);
#endif
		    return OK;
		}
	    }
	}
    }
    else
    if ((PtrTempAddr = strstr(GSMReadBuff, (BYTE *)cStrGSMCMSERROR)) != NULL) {
	GSMReadAddr = PtrTempAddr - GSMReadBuff;

	for (i = GSMReadAddr + LenGSMCMSERROR; i <= GSMReadSize; i++) {
	    if (GSMReadBuff[i - 2] == CR && GSMReadBuff[i - 1] == LF) {
		GSMReadStop = i;
#ifdef SUPPORT_USART_SHOW
		psprintf(LineBuffer, "ERROR:");
		DBusEditShowText(LineBuffer);
		psprintf(LineBuffer, "%d,", GSMReadSize);
		DBusEditShowText(LineBuffer);
#endif
		return ERROR;
	    }
	}
    }

    return IDLE;
}

/************************************************************************
 *  GSM Wait Modem Adopt						*
 *	Wait Modem Adopt from the GSM Module				*
 ************************************************************************/
BYTE GSMWaitModemAdopt(void)
{
    if ((GSMReadUsart() == 0)		||
	(GSMReadSize < GSMSendSize)	||
	(PtrTempAddr = strstr(GSMReadBuff, GSMSendBuff)) == NULL)
	return IDLE;

    GSMReadAddr	= PtrTempAddr - GSMReadBuff;
    GSMReadStop = GSMReadAddr + GSMSendSize;
    return OK;
}

/************************************************************************
 *  GSM Wait Modem Reply						*
 *	Wait Modem Reply from the GSM Module				*
 ************************************************************************/
BYTE GSMWaitModemReply(void)
{
    UINT16		i;
    UINT16		Length;

    if ((GSMReadUsart() == 0)		||
	(GSMReadSize <= GSMSendSize)	||
	(PtrTempAddr = strstr(GSMReadBuff, GSMSendBuff)) == NULL)
	return IDLE;

    GSMReadAddr	= PtrTempAddr - GSMReadBuff;

    if (GSMSendCommType == ATpCMGS) {
	if (memcmp("\x0D\x0A> ", GSMReadBuff + GSMReadAddr + GSMSendSize, 4) == 0) {
	    GSMReadStop = GSMReadAddr + GSMSendSize + 4;
	    return CMGS;
	}
	return IDLE;
    }

    for (i = GSMReadAddr + GSMSendSize + 2; i <= GSMReadSize; i++) {
	if (GSMReadBuff[i - 2] == CR && GSMReadBuff[i - 1] == LF) {
	    GSMReadStop = i;

	    Length = i - GSMSendSize - GSMReadAddr;
	    if (Length >= LenGSMOK &&
		memcmp(GSMReadBuff + i - LenGSMOK, (BYTE *)cStrGSMOK, LenGSMOK) == 0) {
		return OK;
	    }
	    if (Length >= LenGSMERROR &&
		memcmp(GSMReadBuff + i - LenGSMERROR, (BYTE *)cStrGSMERROR, LenGSMERROR) == 0) {
		return ERROR;
	    }
	    if (Length >= LenGSMCONNECT &&
		memcmp(GSMReadBuff + i - LenGSMCONNECT, (BYTE *)cStrGSMCONNECT, LenGSMCONNECT) == 0) {
		return CONNECT;
	    }
	    if (Length >= LenGSMNOCARRIER &&
		memcmp(GSMReadBuff + i - LenGSMNOCARRIER, (BYTE *)cStrGSMNOCARRIER, LenGSMNOCARRIER) == 0) {
		return NOCARRIER;
	    }
	    if (Length >= LenGSMCMEERROR &&
		strstr(GSMReadBuff, (BYTE *)cStrGSMCMEERROR) != NULL) {
		return ERROR;
	    }
	    if (Length >= LenGSMCMSERROR &&
		strstr(GSMReadBuff, (BYTE *)cStrGSMCMSERROR) != NULL) {
		return ERROR;
	    }
	}
    }

    return IDLE;
}

/************************************************************************
 *  GSM Proc Modem Reply						*
 *	Proc Modem Reply from the GSM Module				*
 ************************************************************************/
void GSMProcModemReply()
{
    memcopy(GSMReadBuff + GSMReadAddr,
	    GSMReadBuff + GSMReadStop, GSMReadSize - GSMReadStop + 1);
    GSMReadSize -= GSMReadStop - GSMReadAddr;
    InitSendBuff();
#ifdef DEBUG_WITH_PC
    InitTestBuff();
#endif
}

/************************************************************************
 *  GSM Proc Analyse CSQ						*
 *	Proc Analyse CSQ which in GSMReadBuff[]				*
 ************************************************************************/
void GSMProcAnalyseCSQ(void)
{
    BYTE		Count;
    BYTE		Value;

    Value = 99;
    if (memcmp(GSMReadBuff + GSMSendSize, "\x0D\x0A""+CSQ: ", 8) == 0) {
	StrCurr = GSMReadBuff + GSMSendSize + 8;
	if ((StrNext = strchr(StrCurr, ',')) != NULL) {
	    Count = StrNext - StrCurr;
	    if (Count && Count <= 2 && Str4Dig(StrCurr, Count)) {
		Value = StrCurr[0] - '0';
		if (Count == 2) {
		    Value *= 10;
		    Value += StrCurr[1] - '0';
		}
#ifdef SUPPORT_USART_SHOW
		psprintf(LineBuffer, "CSQ:%02d,", Value);
		DBusEditShowText(LineBuffer);
#endif
	    }
	}
    }

    if (Value == 99)	{ GSMCheckCount++;	}
    else		{ GSMCheckCount	= 0;	}
}

/************************************************************************
 *  GSM Proc Analyse CPMS						*
 *	Proc Analyse CPMS which in GSMReadBuff[]			*
 ************************************************************************/
void GSMProcAnalyseCPMS(void)
{
    BYTE		Count;
    BYTE		Value;
    BYTE		i;

    Value = 99;
    if (memcmp(GSMReadBuff + GSMSendSize, "\x0D\x0A""+CPMS: ", 9) == 0) {
	StrCurr = GSMReadBuff + GSMSendSize + 9;
	for (i = 0; i < 5; i++) {
	    if ((StrNext = strchr(StrCurr, ',')) == NULL)	return;
	    StrCurr = StrNext + 1;
	}
	if ((StrNext = strchr(StrCurr, '\x0D')) != NULL) {
	    Count = StrNext - StrCurr;
	    if (Count && Count <= 2 && Str4Dig(StrCurr, Count)) {
		Value = StrCurr[0] - '0';
		if (Count == 2) {
		    Value *= 10;
		    Value += StrCurr[1] - '0';
		}
		SMSEmptyCount = Value;
#ifdef SUPPORT_USART_SHOW
		psprintf(LineBuffer, "CPMS:%02d,", Value);
		DBusEditShowText(LineBuffer);
#endif
	    }
	}
    }

    if (Value == 99)	{ GSMCheckCount++;	}
    else		{ GSMCheckCount	= 0;	}
}

/************************************************************************
 *  GSM Proc Analyse CPAS						*
 *	Proc Analyse CPAS which in GSMReadBuff[]			*
 ************************************************************************/
void GSMProcAnalyseCPAS(void)
{
    BYTE		Count;
    BYTE		Value;

    if (memcmp(GSMReadBuff + GSMSendSize, "\x0D\x0A""+CPAS: ", 9) == 0) {
	StrCurr = GSMReadBuff + GSMSendSize + 9;
	if ((StrNext = strchr(StrCurr, '\x0D')) != NULL) {
	    Count = StrNext - StrCurr;
	    if (Count && Count <= 2 && Str4Dig(StrCurr, Count)) {
		Value = StrCurr[0] - '0';
		if (Count == 2) {
		    Value *= 10;
		    Value += StrCurr[1] - '0';
		}
		GSMPhoneReady = (Value == 0);
#ifdef SUPPORT_USART_SHOW
		psprintf(LineBuffer, "CPAS:%02d,", Value);
		DBusEditShowText(LineBuffer);
#endif
	    }
	}
    }
}

/************************************************************************
 *  GSM Proc Analyse CMGR						*
 *	Proc Analyse CMGR which in GSMReadBuff[]			*
 ************************************************************************/
void GSMProcAnalyseCMGR(void)
{
}

/************************************************************************
 *  GSM Proc Analyse CGD						*
 *	Proc Analyse CGD which in GSMReadBuff[]				*
 ************************************************************************/
void GSMProcAnalyseCGDC(void)
{
    BYTE		i;

    for (i = 0; i < CGD_COUNT_MAX; i++) {
	psprintf(StrLineBuff, "+CGDCONT: %d,\"IP\",\"%s\",", i + 1, DBusGPRSIPStr);
	CGDCountState[i] = (strstr(GSMReadBuff + GSMSendSize, StrLineBuff) != NULL);
    }
}

/************************************************************************
 *  GSM Proc Send Data							*
 *	Proc Send Data and wait response				*
 ************************************************************************/
BYTE GSMProcSendData(void)
{
    switch (GSMSendDataStep) {
    case STATE_IDLE:
	GSMSendDataStep++;
	break;
    case 0x01:
	GSMUsartSend(GSMSendBuff, GSMSendSize);
	GSMDelayTimer = TIMER_xS(30);
	GSMSendDataStep++;
	break;
    case 0x02:
	GSMFuncReturn = GSMWaitModemAdopt();
	     if (GSMFuncReturn != IDLE)		GSMSendDataStep = STATE_OK;
	else if (GSMDelayTimer == 0)		GSMSendDataStep = STATE_TIMEOUT;
	break;

    case STATE_OK:
#ifdef SUPPORT_USART_SHOW
	psprintf(LineBuffer, "OK,");
	DBusEditShowText(LineBuffer);
#endif
	GSMProcModemReply();
	GSMSendDataStep = STATE_IDLE;		return OK;
	break;

    case STATE_TIMEOUT:
#ifdef SUPPORT_USART_SHOW
	psprintf(LineBuffer, "DAT-TimeOut,");
	DBusEditShowText(LineBuffer);
#endif
	InitReadBuff();
	InitSendBuff();
	GSMSendDataStep = STATE_IDLE;		return TIMEOUT;
	break;
    }

    return IDLE;
}

/************************************************************************
 *  GSM Proc Send Command						*
 *	Proc Send Command and wait response				*
 ************************************************************************/
BYTE GSMProcSendComm(void)
{
    switch (GSMSendCommStep) {
    case STATE_IDLE:
	GSMDelayCount = TIMER_xS(5);		// Set to default wait time
	switch (GSMSendCommType) {
	case AT:
	    strcpy(GSMSendBuff, cStrGSMAT);		GSMSendSize = LenGSMAT;
	    break;
	case ATA:
	    strcpy(GSMSendBuff, cStrGSMATA);		GSMSendSize = LenGSMATA;
	    break;
	case ATH:
	    strcpy(GSMSendBuff, cStrGSMATH);		GSMSendSize = LenGSMATH;
	    break;
	case ATO:
	    strcpy(GSMSendBuff, cStrGSMATO);		GSMSendSize = LenGSMATO;
	    GSMDelayCount = TIMER_xS(30);
	    break;
	case ATpCSQ:
	    strcpy(GSMSendBuff, cStrGSMATpCSQ);		GSMSendSize = LenGSMATpCSQ;
	    break;
	case ATpCMGFe0:
	    strcpy(GSMSendBuff, cStrGSMATpCMGFe0);	GSMSendSize = LenGSMATpCMGFe0;
	    break;
	case ATpCMGFe1:
	    strcpy(GSMSendBuff, cStrGSMATpCMGFe1);	GSMSendSize = LenGSMATpCMGFe1;
	    break;
	case ATpCMGR:
	    strcpy(GSMSendBuff, cStrGSMATpCMGR);
	  psprintf(StrLineBuff, "%d\x0D", GSMSendCommPara);
	   strncat(GSMSendBuff, StrLineBuff);		GSMSendSize = strlen(GSMSendBuff);
	    break;
	case ATpCMGS:
	     strcpy(GSMSendBuff, cStrGSMATpCMGS);
	   psprintf(StrLineBuff, "%d\x0D", GSMSendCommPara);
	    strncat(GSMSendBuff, StrLineBuff);		GSMSendSize = strlen(GSMSendBuff);
	    break;
	case ATpCMGD:
	    strcpy(GSMSendBuff, cStrGSMATpCMGD);
	  psprintf(StrLineBuff, "%d\x0D", GSMSendCommPara);
	   strncat(GSMSendBuff, StrLineBuff);		GSMSendSize = strlen(GSMSendBuff);
	    break;
	case ATpCNMI:
	    strcpy(GSMSendBuff, cStrGSMATpCNMI);	GSMSendSize = LenGSMATpCNMI;
	    break;
	case ATpCPMS:
	    strcpy(GSMSendBuff, cStrGSMATpCPMS);	GSMSendSize = LenGSMATpCPMS;
	    break;
	case ATpCPAS:
	    strcpy(GSMSendBuff, cStrGSMATpCPAS);	GSMSendSize = LenGSMATpCPAS;
	    break;
	case ATpCGDCONT:
	    strcpy(GSMSendBuff, cStrGSMATpCGDCONT);
	  psprintf(StrLineBuff, "%d,\"IP\",\"%s\"\x0D", GSMSendCommPara, DBusGPRSIPStr);
	   strncat(GSMSendBuff, StrLineBuff);		GSMSendSize = strlen(GSMSendBuff);
	    break;
	case ATpCGDCONTq:
	    strcpy(GSMSendBuff, cStrGSMATpCGDCONTq);	GSMSendSize = LenGSMATpCGDCONTq;
	    break;
	case ATpCLIPe1:
	    strcpy(GSMSendBuff, cStrGSMATpCLIPe1);	GSMSendSize = LenGSMATpCLIPe1;
	    break;
	case ATmECAMe1:
	    strcpy(GSMSendBuff, cStrGSMATmECAMe1);	GSMSendSize = LenGSMATmECAMe1;
	    break;
	case ATmE2EAMS:
	    strcpy(GSMSendBuff, cStrGSMATmE2EAMS);	GSMSendSize = LenGSMATmE2EAMS;
	    break;
	case ATmE2IPA0:
	    strcpy(GSMSendBuff, cStrGSMATmE2IPA0);
	  psprintf(StrLineBuff, "%d\x0D", GSMSendCommPara);
	   strncat(GSMSendBuff, StrLineBuff);		GSMSendSize = strlen(GSMSendBuff);
	    GSMDelayCount = TIMER_xS(30);
	    break;
	case ATmE2IPA1:
	    strcpy(GSMSendBuff, cStrGSMATmE2IPA1);
	  psprintf(StrLineBuff, "%d\x0D", GSMSendCommPara);
	   strncat(GSMSendBuff, StrLineBuff);		GSMSendSize = strlen(GSMSendBuff);
	    GSMDelayCount = TIMER_xS(60);
	    break;
	case ATmE2IPO:
	    strcpy(GSMSendBuff, cStrGSMATmE2IPO);
	  psprintf(StrLineBuff, "1,\"%d.%d.%d.%d\",%04d\x0D",	// TCP
		   DBusLinkIP[0], DBusLinkIP[1], DBusLinkIP[2], DBusLinkIP[3],
		   DBusPortIP);
	   strncat(GSMSendBuff, StrLineBuff);		GSMSendSize = strlen(GSMSendBuff);
	    GSMDelayCount = TIMER_xS(30);
	    break;
	case ATmE2IPC:
	    strcpy(GSMSendBuff, cStrGSMATmE2IPC);	GSMSendSize = LenGSMATmE2IPC;
	    break;
	case CTRL_Z:
	    strcpy(GSMSendBuff, cStrSMSInfoTail);	GSMSendSize = LenSMSInfoTail;
	    GSMDelayCount = TIMER_xS(60);
	    break;
	}
	GSMSendCommStep++;
	break;
    case 0x01:
	GSMUsartSend(GSMSendBuff, GSMSendSize);
	GSMDelayTimer = GSMDelayCount;
	GSMSendCommStep++;
	break;
    case 0x02:
	GSMModemReply = GSMWaitModemReply();
	     if (GSMModemReply != IDLE)		GSMSendCommStep++;
	else if (GSMDelayTimer == 0)		GSMSendCommStep = STATE_TIMEOUT;