sms.c

GSM通讯的C语言源程序代码

//-----------------------------------*/
#define SMS_GLOBAL
#include "includes.h"
//===================================
uchar SmsInit(void)
{
  static uchar InitFail = 10,index = 0,Res = 0,TimeOut = 0;
  static bit SendFlag = 1;
  if(SendFlag)
  {
  	mComLen = 0;
    while(ModemCommand[index][mComLen] != '\r') 
	{
      SmsTxBuffer[mComLen++]  = ModemCommand[index][mComLen];
    }
	SmsTxBuffer[mComLen++] = '\r';
    SBUF0 = SmsTxBuffer[0];
    mComSlot = 1;
    Tim100MS = 0;
	SendFlag = 0;
  }
  else
  {
  	if(Tim100MS)
	{
		Tim100MS = 0;
	    mComLen = 0;
 		Res = Waitfor(OK);
		if( !Res)
		{
			if(TimeOut++ > 60)
			{
			 	if(InitFail-- ==0)
			  	{
				 	SmsInitState = 0x11;
					InitFail = 10;
			   		return(FALSE);
			  	}
				else
				{
					ModemInit();
					index = 0; 
					TimeOut = 0;
		    		SendFlag = 1; 
				}
			}
		}
		else
		{
			if(index ++ >= MODEMCOMMANDCON - 1)
			{
				SmsInitState = 0xAA;
				SmsPointerInit();
			    SmsBindBuff(InputBuffer);
			    Comm0EvtPointer = ProcSmsReceive; 
			    SmsReceiveStatus = 0; 
			    return(TRUE);
			}
			else
			{
			    SendFlag = 1; 
			}
		} 
	}
  }
}
//-------------------------------------
void ProcSmsReceive(void)
{
  if(RxSmsSize == 0) {
    switch (cData) {
      case '>':
      	SmsReceiveStatus |= SendSmsBZ;
      	break;
      case '+':
        SmsBuffer[RxSmsSize++] = cData;
	    RxDataTypeFlag = 1;
        break;
      case '0':
      	SmsReceiveStatus |= RxOkBZ;
      	break;
      case '2':
        SmsReceiveStatus |= RxRingBZ;
      	break;
      default :
        break;
    }
  }
  else { 
    switch (RxDataTypeFlag) {
      case 1 :
      	SmsBuffer[RxSmsSize++] = cData;
      if(cData == 0x0a) {     
          if(!memcmp(InputBuffer,CMT,4)) {
	  	  	RxSmsSize2 = 0;
	      	RxDataTypeFlag = 2;
	      }
	  else if(!memcmp(InputBuffer,CSCA,5)) {
	    SmsReceiveStatus |= RxCscaOkBZ;
	    RxSmsSize = 0;
	    RxDataTypeFlag = 0 ;
	  }
	  else if(!memcmp(InputBuffer,CCLK,5)) {
	    SmsReceiveStatus |= RxCclkOkBZ;
	    memcpy(TimeBuff,&InputBuffer[8],17);
	    RxSmsSize = 0;
	    RxDataTypeFlag = 0 ;
	  }
	  else if(!memcmp(InputBuffer,CSQ,4)) {
	    SmsReceiveStatus |= RxCsqOkBZ;
	    memcpy(CsqBuff,&InputBuffer[6],4); 
	    RxSmsSize = 0;
	    RxDataTypeFlag = 0 ;
	  }
	  else if(!memcmp(InputBuffer,CNMA,5)) {
	    SmsReceiveStatus |= RxCnmaOkBZ;
	    RxSmsSize = 0;
	    RxDataTypeFlag = 0 ;
	  }
	  else if(!memcmp(InputBuffer,CLIP,5)) {  
	    memcpy(ClipTelNumber,&InputBuffer[8],11);
	    SmsReceiveStatus |= RxRingBZ;
        RxClipBZ = 1; 
	    RxSmsSize = 0;
	    RxDataTypeFlag = 0 ;
	  }
	  else if(!memcmp(InputBuffer,CMGS,3)) {
        RxCmgsBZ = 1;
	    RxSmsSize = 0;
	    RxDataTypeFlag = 0 ;
	  }
	  else {
	    RxSmsSize = 0;
	    RxDataTypeFlag = 0;
	  } 
	}
	break;
    case 2:
      SmsBuffer[RxSmsSize2++] = cData;
      if(cData == 0x0a) {  
        RxSmsSize = 0;
	    RxCmtOkBZ = 1; 
	    RxDataTypeFlag = 0;
	  }
	break;
    default :
      RxSmsSize = 0;
      RxDataTypeFlag = 0 ;
    break;
    }
  }
}    
//-------------------------------------*/
void SmsBindBuff(uchar *lpInputBuffer)
{
	SmsBuffer = lpInputBuffer;
}
//-------------------------------------*/
void SmsPointerInit(void)
{
	InputBuffNoEmptyBZ = FALSE;
	InputBuff1NoEmptyBZ = FALSE;
}
//--------------------------------------------------
uchar SmsChuLi(uchar xdata *SmsChuLBbuffer)
{
  uchar tmp;

    String2Bytes(SmsChuLBbuffer,&tmp,2); 
    tmp = (tmp - 1) * 2; 
    SmsChuLBbuffer += 4;  
    SerializeNumbers(SmsChuLBbuffer, SmsCode.SCA, tmp); 
    SmsChuLBbuffer += tmp; 
    String2Bytes(SmsChuLBbuffer, &tmp, 2);
    SmsChuLBbuffer += 2;
    String2Bytes(SmsChuLBbuffer, &tmp, 2);
    if(tmp & 1) tmp += 1; 
    SmsChuLBbuffer += 4; 
    SerializeNumbers(SmsChuLBbuffer, SmsCode.TPA, tmp); 
    SmsChuLBbuffer += tmp;       
    String2Bytes(SmsChuLBbuffer, &SmsCode.TP_PID, 2);  
    SmsChuLBbuffer += 2;      
    String2Bytes(SmsChuLBbuffer, &SmsCode.TP_DCS, 2);    
    SmsChuLBbuffer += 2;      
    SerializeNumbers(SmsChuLBbuffer, SmsCode.TP_SCTS, 14);     
    SmsChuLBbuffer += 14;      
    String2Bytes(SmsChuLBbuffer, &tmp, 2); 
	SmsCode.TP_UDLEN = tmp;
    SmsChuLBbuffer += 2;       
    if(SmsCode.TP_DCS == GSM_UCS2)
    {
        String2Bytes(SmsChuLBbuffer, SmsCode.TP_UD, tmp * 2); 
		if(((SmsCode.TP_UD[1] == 0x2A) || (SmsCode.TP_UD[1] == 0x0A))&& ((SmsCode.TP_UD[19] == 0x23) || (SmsCode.TP_UD[19] == 0x03)))
		{
			for(tmp=1;tmp<9;tmp++)
			{
      			UnCode_Data[tmp-1] = SmsCode.TP_UD[tmp*2];
 				UnCode_Data[tmp-1] = UnCode_Data[tmp-1] << 8 ;
				UnCode_Data[tmp-1] = UnCode_Data[tmp-1] + SmsCode.TP_UD[tmp*2 + 1];
				GB2312_Data[tmp-1] = UnicodetoGB2312(UnCode_Data[tmp-1]);
				return(TRUE);
			}
		} 
		else{
		  return(FALSE);
		}
    }
	else
	{
		return(FALSE);
	}
}
//=====================================================================================
void ProcSmsSend2(void)
{            
    uchar nLength,i;
	uchar code tmp[] = "6210529F63A56536FF1A";
    uchar nDstLength;   
    uchar buf[20];  
//******************************************************************************************
      buf[0] = 0x00;
      nDstLength = Bytes2String(buf, SmsTxBuffer2, 1); 
//******* ***************************************************************************   
    nLength = strlen(SmsCode.TPA);
    buf[0] = 0x11;      
    buf[1] = 0;      
    buf[2] = (uchar)nLength;  
    buf[3] = 0x91;         
    nDstLength += Bytes2String(buf, &SmsTxBuffer2[nDstLength], 4);  
    nDstLength += InvertNumbers(SmsCode.TPA, &SmsTxBuffer2[nDstLength], nLength); 
    nLength = strlen(SmsCode.TP_UD);    
    buf[0] = SmsCode.TP_PID;     
    buf[1] = 0x08;       
    buf[2] = 0;      
	buf[3] = SmsCode.TP_UDLEN + 10; 
    nDstLength += Bytes2String(buf, &SmsTxBuffer2[nDstLength], 4);       
	for(i=0;i<20;i++)
	{
		SmsTxBuffer2[i+nDstLength] = tmp[i];
	}
	nDstLength = nDstLength + 20;
    if(SmsCode.TP_DCS == GSM_UCS2) {
        nDstLength += Bytes2String(SmsCode.TP_UD, &SmsTxBuffer2[nDstLength], SmsCode.TP_UDLEN);  
    }
SmsTxBuffer2[nDstLength++] = 0x1a;
}
//------------------------------------
void ProcSmsSend1(void)
{
  uchar i;
  for(i=0;i<8;i++){
    SmsTxBuffer1[i] = AT_CMGS[i];
  }
  SmsTxBuffer1[8] = '0'; 
  SmsTxBuffer1[9] = '4'; 
  SmsTxBuffer1[10] = '5'; 
  SmsTxBuffer1[11] = '\r'; 
}
//--------------------------------------------------------
void ProcSmsSend(uchar *Input,uchar len)
{
  SmsTxBuffer = Input;
  mComLen = len;
  SBUF0 = SmsTxBuffer[0];
  mComSlot = 1;
}
//==========================================================
uchar String2Bytes(uchar *Src, uchar *Dst, uchar nSrcLength)
{
	uchar i;
    for(i=0; i<nSrcLength; i+=2) {
        if(*Src>='0' && *Src<='9') {
            *Dst = (*Src - '0') << 4;
        }
        else {
            *Dst = (*Src - 'A' + 10) << 4;
        }
        Src++; 
        if(*Src>='0' && *Src<='9') {
            *Dst |= *Src - '0';
        }
        else {
            *Dst |= *Src - 'A' + 10;
        }
        Src++;
        Dst++;
    }
    return nSrcLength / 2;
}
//==============================================================
uchar Bytes2String(uchar *Src, uchar *Dst, uchar nSrcLength)
{
	uchar i;
    uchar code tab[]="0123456789ABCDEF"; 
    for(i=0; i<nSrcLength; i++)
    {
        *Dst++ = tab[*Src >> 4];
        *Dst++ = tab[*Src & 0x0f];
        Src++;
    }
    *Dst = '\0';
    return nSrcLength * 2;
}
//====================================================================
uchar InvertNumbers(uchar *Src, uchar *Dst, uchar nSrcLength)
{
    uchar nDstLength,i,ch;
    nDstLength = nSrcLength;
    for(i=0; i<nSrcLength;i+=2) {
        ch = *Src++;
        *Dst++ = *Src++;
        *Dst++ = ch;
    }
    if(nSrcLength & 1) {
        *(Dst-2) = 'F'; 
        nDstLength++;
    }
    *Dst = '\0';
    return nDstLength;
}
//==================================================================    
uchar SerializeNumbers(uchar *Src, uchar *Dst, uchar nSrcLength)
{
    uchar i,nDstLength,ch;
    nDstLength = nSrcLength;
    for(i=0; i<nSrcLength;i++,i++) {
        ch = *Src++; 
        *Dst++ = *Src++;
        *Dst++ = ch;
    }
    if(*(Dst-1) == 'F') {
        Dst--;
        nDstLength--;
    }
    *Dst = '\0';
    return nDstLength;
}
//===================================================================
void SmsProc(void)
{
	uchar TempVal,TempBuff[3] = {"00"};
	static uchar xdata WaitCmdCon = 0,i = 0,SmsSendFail = 0;
	static bit SendCSQBZ = 0;
    if((!RxCmtOkBZ) && ShowTimeBZ)
	{
		if(!SendCSQBZ)
		{
    		while(AT_CSQ[mComLen] != '\r') 
			{
      			SmsTxBuffer[mComLen++]  = AT_CSQ[mComLen];
    		}
			SmsTxBuffer[mComLen++] = '\r';
    		SBUF0 = SmsTxBuffer[0];
    		mComSlot = 1;
			SendCSQBZ = 1;
			ShowTimeBZ = 0;
		}
		else if(SendCSQBZ)
		{
			if(SmsReceiveStatus & RxCsqOkBZ) 		
			{
				SendCSQBZ = 0;
				memcpy(TempBuff,CsqBuff,2);
    			TempVal = atoi(TempBuff); 
    			if(TempVal == 99) {
      				SignalFlag = 0;
    			}
    			else if(TempVal > 23) { 
      				SignalFlag = 4;
    			}
    			else if(TempVal > 15) { 
      				SignalFlag = 3;
    			}
    			else if(TempVal > 7) { 
      				SignalFlag = 2;
    			}
    			else  
      				SignalFlag = 1;
		  	    SmsReceiveStatus &= ~RxCsqOkBZ;
				SendCSQBZ = 0;
				ShowTimeBZ = 0;
			}
		}
	}
//-----------------------------------
    if(RxCmtOkBZ) { 
      switch (SmsState) {
        case 0x01:
          i = SmsChuLi(SmsBuffer);
		  if(i){
	        ProcSmsSend2();
            SmsState = 0x02;
		  }
		  else{
		    SmsState = 0x04;
		  	SmsReceiveStatus &= ~RxCnmaOkBZ;
		  	RxCmgsBZ = 1;
            RxCmtOkBZ = 1;
			WaitCmdCon = 0;
          }
      	  break;
        case 0x02:
          ProcSmsSend1();
          ProcSmsSend(SmsTxBuffer1,12);
          SmsState = 0x03;
		  WaitCmdCon = 0;
          break;
        case 0x03:
          if(Tim100MS)
		  {
            Tim100MS = 0;
	  	    if(SmsReceiveStatus & SendSmsBZ)
			{
              ProcSmsSend(SmsTxBuffer2,93);
		  	  SmsReceiveStatus &= ~SendSmsBZ;
	          SmsState = 0x04;
			  RxCmgsBZ = 0;
			  WaitCmdCon = 0;
		    }
		    else if(WaitCmdCon++ > 200)  //10S
  			{
			  WaitCmdCon = 0;
			  if(SmsSendFail++>10)
			  {
			    SmsSendFail = 0;
                SmsState = 0x02;
		  	  	WaitCmdCon = 0;
       			RxCmtOkBZ = 0;
				//The SMS is Send Fail proc
			   }
			}
		  }
          break;
        case 0x04:
          if(Tim100MS == 1)
		  {
            Tim100MS = 0;
            if(RxCmgsBZ)
			{
		      SmsState = 0x05;
			  WaitCmdCon = 0;
		  	  SmsReceiveStatus &= ~RxOkBZ;
			  mComLen = 0;
    		  while(AT_CNMA[mComLen] != '\r') {
      	        SmsTxBuffer[mComLen++]  = AT_CNMA[mComLen];
              }
	          SmsTxBuffer[mComLen++] = '\r';
              SBUF0 = SmsTxBuffer[0];
		      mComSlot = 1;

		      //The SMS is Send Success proc
		  	}
		    else if(WaitCmdCon++ > 250)//
  			{
			  WaitCmdCon = 0;
			  if(SmsSendFail++>10)
			  {
		      	SmsState = 0x02;
		  	  	WaitCmdCon = 0;
			    SmsSendFail = 0;
                RxCmtOkBZ = 0;
				//The SMS is Send Fail proc
			   }
			}
		  }
      	  break;
        case 0x05:
          if(Tim100MS == 1)
		  {
            Tim100MS = 0;
            if(SmsReceiveStatus & RxCnmaOkBZ)
			{
		      SmsState = 0x01;
		  	  SmsReceiveStatus &= ~RxCnmaOkBZ;
		  	  RxCmgsBZ = 0;
              RxCmtOkBZ = 0;
			  WaitCmdCon = 0;
		  	}
		    else if(WaitCmdCon++ > 250)//
  			{
	      	  SmsState = 0x04;
			  WaitCmdCon = 0;
			  if(SmsSendFail++>2)
			  {
				SmsInitState = 0x55;
  				ModemInit (); 
  				ModemBindBuff(InputBuffer);  
  				Comm0EvtPointer = ProcModemReceive; 
		  	  	WaitCmdCon = 0;
				SmsState = 0x01;
			    SmsSendFail = 0;
                RxCmtOkBZ = 0;
			  }
			}
		  }
      	  break;
        default :
	      SmsState = 0x01;
          RxCmtOkBZ = 0;
          break;
      }
	}
}
//-----------------------------------------
void SMSInItPointer(void)
{
  SmsState = 0x01;
  SmsInitState = 0x55;
  ModemInit (); 
  ModemBindBuff(InputBuffer);   
  Comm0EvtPointer = ProcModemReceive; 
}