isomodem_ppp.c

modem数据通信源码

#include "44b.H"
#include "EPT32.H"
#include "Nucleus.H"
#include "string.h"
#include "switch.h"    

#include "interdrive.h"
#include "common_exp.h"
#include "ISOModem_DRV.h"
#include "Modem_IODrv.h"
#include "Protocol_Drv.h"
#include "exports.h"
#include "IODrive.h"
#include "Regist.h"

#include "ISOModem.h"

extern EM_modem_STS    EG_modem_STS;

uchar	EI_ppp_Write(uint uiBufSize,char *pcBuf);
uchar   EI_ppp_Read(uchar *ch);
uchar EI_ppp_GetState( ET_EVENT_STRUCT *ptEventState );

uchar	EI_ppp_Write(uint uiBufSize,char *pcBuf)
{
    EA_ucWriteDeviceMs(EG_modem_STS.uarthandle,uiBufSize,10,pcBuf);
    return EM_SUCCESS;
}

uchar   EI_ppp_Read(uchar *ch)
{
    if(loop_read(EG_modem_STS.serial_recvbuf,(char *)ch,1)>0)
        return EM_SUCCESS;
    else
        return EM_ERROR;
}

void EI_ModemStartPpp(void)
{
    EA_ppp_ucCall();
}

uchar EA_MODEM_ucInitPpp(DevHandle hDevHandle)
{
    ET_PPP_DEVINTER tParam	;	
    ET_PPP_PWM_STRUCT tPwmEntry ;
    
    uprintf("API:%s\r\n",__FUNCTION__);
        
	if(EI_VerifyHandle_ppp(hDevHandle)!=EM_SUCCESS)	
		return EM_ERRHANDLE;		

    
    tParam.m_ptMbIcon = NULL;
    tParam.ucWriteBuf = EI_ppp_Write;
    tParam.ucReadByte = EI_ppp_Read;
    tParam.ptPwmStruct = &tPwmEntry;
    tParam.ptPwmStruct->vIntoPowerSave = NULL;
    tParam.ptPwmStruct->vOutOfPowerSave = NULL;    
    EA_ppp_vSetParam( &tParam ) ;
    
    if(EI_InitDial(EM_modem_33600BPS,EM_modem_NOPAR,EM_modem_8DBS)!=EM_SUCCESS)
        return EM_ERROR;
    
    EG_modem_STS.ppp_state = EM_PPP_INITED;
    EG_modem_STS.mode = EM_MODEM_MODE_PPP;
    return EM_SUCCESS;
}

uchar EA_MODEM_ucDialOffPpp(DevHandle hDevHandle)
{
    ET_EVENT_STRUCT	tEventState ;
    UNSIGNED time_start,time_cur;

	uprintf("API:%s\r\n",__FUNCTION__);
        
	if(EI_VerifyHandle_ppp(hDevHandle)!=EM_SUCCESS)	
		return EM_ERRHANDLE;
	
    if(EG_modem_STS.ppp_state!=EM_PPP_INITED)
        return EM_ppp_NOINIT;
    
    if(EG_modem_STS.online==EM_ONLINE_OFFLINE
       ||EG_modem_STS.online==EM_ONLINE_AT
       )
    {
        EA_ppp_ucDialOff(1);
    }
    else
    {
        if(EA_ppp_ucDialOff(0)==EM_SUCCESS)	
        {
            time_start = NU_Retrieve_Clock();
        	tEventState.ucEvent = PROTO_TERM_EVENT;	
        	while(1)
        	{		    
        	    EA_ppp_ucGetState(&tEventState);
        	    time_cur = NU_Retrieve_Clock();
        	    if(tEventState.ucRet == EM_SUCCESS
        	        ||time_cur>=time_start+EM_TIME_TICK_IN1S*3
        	        )
        	    {
        	        /*PPP dialoff success or time out */
        	        break;
        	    }
        	}
        }
    }
	
	return(EA_ucDialOff(hDevHandle));	
}

uchar EI_ppp_GetState( ET_EVENT_STRUCT *ptEventState )
{
    uchar ucRet = EM_ERROR;
    
    if( ptEventState == NULL )
		return EM_ERROR ;		
    
	switch( ptEventState->ucEvent )
	{
		case PROTO_CONNECT_EVENT:
		    if(EG_modem_STS.online==EM_ONLINE_DATA)
		    {
		        ucRet = EA_ppp_ucGetState( ptEventState);
		    }
		    else if(EG_modem_STS.online==EM_ONLINE_AT)
		    {
		        ucRet = EM_ERROR;
		    }
		    else if(EG_modem_STS.online==EM_ONLINE_OFFLINE)
		    {
		        ptEventState->ucRet = EM_ppp_DIALFAIL;
	            ucRet = EM_SUCCESS;
		    }
		    else
		    {
		        /* dialing */
		        ptEventState->ucRet = EM_ppp_Dialing;
	            ucRet = EM_SUCCESS;
		    }
		    break;
		case PROTO_TERM_EVENT:
		    if(EG_modem_STS.online==EM_ONLINE_DATA)
		    {
		        /* dialoff not success */
		        ptEventState->ucRet = EM_ERROR ;
                ucRet = EM_SUCCESS ;
            }
            else
            {
                ptEventState->ucRet = EM_SUCCESS ;
                ucRet = EM_SUCCESS ;
            }
			break ;
		default :
			ucRet = EA_ppp_ucGetState(ptEventState);
			break ;
	}
	return ucRet;
}

uchar EA_MODEM_ucGetState( DevHandle hDevHandle , void *pt )
{
	uchar           ucRet;
	uchar	        result ;
	ET_EVENT_STRUCT *ptEventState;
    
	ucRet = EI_VerifyHandle_ppp(hDevHandle);
	if(ucRet != EM_SUCCESS)
		return EM_ERRHANDLE;
	if(pt==NULL)
	    return EM_ERROR;
	if(EG_modem_STS.ppp_state!=1)
        return EM_ppp_NOINIT;
    
	ptEventState = (ET_EVENT_STRUCT *)pt;	

    result = EI_ppp_GetState(ptEventState);

	return result ;
}

uchar EA_MODEM_ucCallPpp(DevHandle hDevHandle, void *pt )
{
    ET_PPP_PARA *ptParam;
	char	dial_num[100];
	uchar   ucRet;
	
	uprintf("API:%s\r\n",__FUNCTION__);
    ucRet = EI_VerifyHandle_ppp(hDevHandle);
	if(ucRet != EM_SUCCESS)
		return EM_ERRHANDLE;
    if(!pt)
        return EM_ERROR;
        
	ptParam = (ET_PPP_PARA *)pt;
	memset(dial_num,0x00,sizeof(dial_num));
	if(EG_modem_STS.ppp_state!=EM_PPP_INITED)
        return EM_ppp_NOINIT;
        
    strcpy(dial_num,"ATD");
	if(ptParam->ucDtmfPulse == EM_modem_PLUSMODE )
		strcat(dial_num,"P");
	else
		strcat(dial_num,"T");
    strcat(dial_num,ptParam->acDialNum);
    strcat(dial_num,"\r");
    
    return(EA_ucDial(hDevHandle,(const char *)dial_num));
}