isomodem.c

modem数据通信源码

        {
            
        }
        else
        {
            uprintf("Drv not initialized 1\r\n");
            return EM_ERROR;
        }
    }
    else
    {
        uprintf("Drv not initialized 2\r\n");    	
    	return EM_ERROR;
    }
#endif
    loop_reset(EG_modem_STS.serial_recvbuf);
    loop_reset(EG_modem_STS.v80_recvbuf);
    loop_reset(EG_modem_STS.hdlc_recvbuf);   
    
	if( (ret = EI_OpenSerial())!=EM_SUCCESS)
    	return ret;
        
    /* check if modem active */
    if(EI_ActiveModem()!=EM_SUCCESS)
        EI_ResetModem();
    if(EI_PatchModem()!=EM_SUCCESS)
        goto drvopen_err1;
    
    NU_Obtain_Semaphore(&(EG_modem_STS.drv_api_SEM),NU_SUSPEND);
    EI_SetModemOnline(EM_ONLINE_AT);
    NU_Release_Semaphore(&(EG_modem_STS.drv_api_SEM));
    
    EI_vOutOfPowerSave();    
    return EM_SUCCESS;

drvopen_err1:
	EI_StopSerial(); 
    return EM_ERROR;
}

uchar   EA_MODEM_ucDrvClose(DevHandle hDevHandle)
{
    UNSIGNED time_cur,sleep_time;
    uchar   ucMode;
    
    uprintf("%s\r\n",__FUNCTION__);
    
    if(EI_JudgeModemHandle(hDevHandle,&ucMode)!=EM_SUCCESS)
        return EM_ERRHANDLE;
    if(EG_modem_STS.online!=EM_ONLINE_AT)
    {
        uprintf("WARN: not in AT,dialoff!\r\n");
        if(EG_modem_STS.mode==EM_MODEM_MODE_PPP)
        {
            EA_MODEM_ucDialOffPpp(hDevHandle);            
        }
        else        
            EA_ucDialOff(hDevHandle);        
    }
    EG_modem_STS.ppp_state = EM_PPP_NOINIT;
    time_cur = NU_Retrieve_Clock();
    uprintf("to last dialoff: %dms \n",(time_cur-EG_modem_STS.dialoff_start)*10);
    switch(EG_modem_STS.modem)
    {
        case EM_MODEM_CX:
            if(EG_modem_STS.dev==DEV_HAND)
            {
                /* hand dev,let modem go into stop mode */
                uprintf("CX hand dev\r\n");
                if(time_cur<EG_modem_STS.dialoff_start+EM_TIME_TICK_IN1S)
                {
                	sleep_time = EM_TIME_TICK_IN1S - (time_cur - EG_modem_STS.dialoff_start);
                	NU_Sleep(sleep_time);
                	uprintf("sleep %dms\r\n",sleep_time*10);
                	EI_StopCx();
                	NU_Sleep(2);                    
                }
                else
                {
                    EI_StopCx();                    
                    NU_Sleep(2);
                }                
            }
            else
            {
                /* not hand dev,do nothing,not into stop mode */
            }
            break;
        case EM_MODEM_SI:
            if(EG_modem_STS.dev==DEV_HAND)
                EI_StopSi();                
            break;
        default:
            break;
    }
    EI_StopSerial();  
    return EM_SUCCESS;
}

uchar	EA_ucDial(DevHandle hDev, const char *pcsBuf)
{
    char    dialstr[100];
    uchar ucMode;
    
    uprintf("API:%s\r\n",__FUNCTION__);
    uprintf("dial: %s",pcsBuf);
    if(EI_JudgeModemHandle(hDev,&ucMode)!=EM_SUCCESS)
        return EM_ERRHANDLE;
    if(pcsBuf==NU_NULL || (strlen(pcsBuf)==0)||(strlen(pcsBuf)>50))
        return EM_ERRPARAM;
            
    if(EG_modem_STS.online!=EM_ONLINE_AT
        &&EG_modem_STS.online!=EM_ONLINE_OFFLINE
        )
        return EM_ERROR;
    
    memset(dialstr,0,sizeof(dialstr));
    memcpy(dialstr,pcsBuf,strlen(pcsBuf));
    if(strstr(dialstr,"\r")==NULL)
        strcat(dialstr,"\r");
        
    if(strstr(dialstr,"ATDT")==NU_NULL
        &&strstr(dialstr,"ATDP")==NU_NULL
        )
    {
        /* AT cmd */
        if(strstr(dialstr,"AT+PATCH")!=NULL)
        {
            uchar ucRet;
            ucRet = EI_ATPatch((char *)dialstr);
            if(ucRet==EM_SUCCESS)
                return EM_modem_ATCOMRIGHT;
            else if(ucRet==EM_modem_NOPATCH)
                return EM_modem_NOPATCH;
            else
                return EM_modem_ATCOMERROR;
        }
        else if(strstr(dialstr,"AT+IOCTL")!=NULL)
        {
            return(EI_ucModemIoctl(dialstr));
        }
        else
        {
            uchar ucRet;
            ucRet = EI_SendAT_OK((char *)dialstr,3);
            if(ucRet==EM_SUCCESS)
                return EM_modem_ATCOMRIGHT;
            else 
                return EM_modem_ATCOMERROR;
        }
    }
    EI_vLineToModem();
    
    if(EI_SendATE0_OK()!=EM_SUCCESS)
        goto dial_err;
    switch(EG_modem_STS.modem)
    {
        case EM_MODEM_CX:
            if(EI_SendAT_OK("ATS12=2\r",1)!=EM_SUCCESS
                )
                goto dial_err;            
            break;
        case EM_MODEM_SI:
            if(EI_SendAT_OK("AT\\V2\r",1)!=EM_SUCCESS
                ||EI_SendAT_OK("ATS12=2\r",1)!=EM_SUCCESS
                )
                goto dial_err;
            break;
        default:
            goto dial_err;
    } 
    
    /* here we must protect it */
    NU_Obtain_Semaphore(&(EG_modem_STS.drv_api_SEM),NU_SUSPEND);
    EI_SetModemOnline(EM_ONLINE_DIALING);
    EG_modem_STS.dialing_buf_len = 0;
    memset(EG_modem_STS.dialing_buf,0x00,sizeof(EG_modem_STS.dialing_buf));
    EG_modem_STS.dial_err = EM_DIALERR_NONE;
    EG_modem_STS.dial_start = NU_Retrieve_Clock();    
    EG_modem_STS.dial_connect = 0;
    EI_vShow(EM_icon_SHOW,EM_icon_MODEM);
    loop_reset(EG_modem_STS.serial_recvbuf);
    NU_Release_Semaphore(&(EG_modem_STS.drv_api_SEM));
    
    EI_SendAT(dialstr);
    return EM_SUCCESS;
dial_err:
    EI_vLineToPhone();
    return EM_ERROR;
}

uchar	EA_ucDialOff(DevHandle hDev)
{
    uchar ucMode;
    
    uprintf("API:%s\r\n",__FUNCTION__);
    if(EI_JudgeModemHandle(hDev,&ucMode)!=EM_SUCCESS)
        return EM_ERRHANDLE;    
        
    EI_vShow(EM_icon_HIDDEN,EM_icon_ONLINE);
	EI_vShow(EM_icon_HIDDEN,EM_icon_DCD);
	EI_vShow(EM_icon_HIDDEN,EM_icon_MODEM);
	
	NU_Obtain_Semaphore(&(EG_modem_STS.drv_api_SEM),NU_SUSPEND);
	EI_SetModemOnline(EM_ONLINE_AT);
	EG_modem_STS.dial_err = EM_DIALERR_NONE;
	NU_Release_Semaphore(&(EG_modem_STS.drv_api_SEM));
	
	/* add DTR func here */
    rPDATC |= EM_MODEM_DTR;
    uprintf("set dtr to inactive\n");
	NU_Sleep(20);
	rPDATC &= ~EM_MODEM_DTR;	
	uprintf("set dtr to active\n");
	
	NU_Sleep(5);
	EI_WriteUart("+++",3);
	NU_Sleep(10);
	EI_WriteUart("ATH0\r",5);
	NU_Sleep(5);
	
	EI_vLineToPhone();
	loop_reset(EG_modem_STS.serial_recvbuf);
    loop_reset(EG_modem_STS.v80_recvbuf);
    loop_reset(EG_modem_STS.hdlc_recvbuf);
	EG_modem_STS.dialoff_start = NU_Retrieve_Clock();	
	
    return EM_SUCCESS;
}

uchar	EA_ucInitSdlc(DevHandle hDev,uchar ucBPS,
					  uchar ucSdlcAD, uchar ucSST)
{
    uchar ret;
    
    uprintf("API:%s\r\n",__FUNCTION__);
    ret = EI_VerifyHandle_sync(hDev);
	if(ret != EM_SUCCESS)
		return EM_ERRHANDLE;		
    	    
    if(EG_modem_STS.online!=EM_ONLINE_OFFLINE
       &&EG_modem_STS.online!=EM_ONLINE_AT)
	    return EM_ERROR;
	if(ucBPS!=EM_modem_V22FC
	    &&ucBPS!=EM_modem_V22
	    &&ucBPS!=EM_modem_V22BIS
	    &&ucBPS!=EM_modem_Bell212
	    )
	    return EM_ERROR;
	if(EG_patch_Info.ucProfileUse==1
	    &&EG_patch_Info.uiInitSdlcLen>0
	    )
	{
	    uprintf("use patch initsdlc\r\n");
	    if(EI_PatchAT(EG_patch_Info.m_pcInitSdlc,EG_patch_Info.uiInitSdlcLen)!=EM_SUCCESS)
	        return EM_ERROR;
	}
	else
	{
	    switch(EG_modem_STS.modem)
        {
            case EM_MODEM_CX:
                if(ucBPS==EM_modem_V22FC)   /* EM_modem_1200BPS */   
                    ret = EI_SendAT_OK("AT%C0\\N0;+A8E=,,,0;$F2;+MS=V22;+ES=6,,8;+ESA=0,0,,,1,0;S17=13\r",3);
                else if(ucBPS==EM_modem_V22)
                    ret = EI_SendAT_OK("AT%C0\\N0;+A8E=,,,0;$F0;+MS=V22;+ES=6,,8;+ESA=0,0,,,1,0;S17=13\r",3);
                else if(ucBPS==EM_modem_V22BIS)
                    ret = EI_SendAT_OK("AT%C0\\N0;+A8E=,,,0;$F0;+MS=V22B;+ES=6,,8;+ESA=0,0,,,1,0;S17=13\r",3);
                else if(ucBPS==EM_modem_Bell212)
                    ret = EI_SendAT_OK("AT%C0\\N0;+A8E=,,,0;$F2;+MS=B212;+ES=6,,8;+ESA=0,0,,,1,0;S17=13\r",3);
                /*else if(ucBPS==EM_modem_V29FC)
                    ret = EI_SendAT_OK("AT%C0\\N0;+A8E=,,,0;$F4;+ES=6,,8;+ESA=0,0,,,1,0;S17=13\r",3);*/
                else
                    ret = EI_SendAT_OK("AT%C0\\N0;+A8E=,,,0;$F2;+MS=V22;+ES=6,,8;+ESA=0,0,,,1,0;S17=13\r",3);                
                break;
            case EM_MODEM_SI:
                if(EI_SendAT_OK("AT\\N0\r",1)!=EM_SUCCESS
                    ||EI_SendAT_OK("AT+ES=6,,8\r",1)!=EM_SUCCESS
                    ||EI_SendAT_OK("AT+ESA=0,0,0,,1,0\r",1)!=EM_SUCCESS
                    ||EI_SendAT_OK("AT+IFC=2,2\r",1)!=EM_SUCCESS
                    ||EI_SendAT_OK("AT+ITF=0383,0128\r",1)!=EM_SUCCESS
                    ||EI_SendAT_OK("AT:U87,050A\r",1)!=EM_SUCCESS
                    ||EI_SendAT_OK("AT+MS=V22\r",1)!=EM_SUCCESS
                    ||EI_SendAT_OK("AT:U7A,3\r",1)!=EM_SUCCESS
                    )
                    ret = EM_ERROR;
                else
                    ret = EM_SUCCESS;
                break;
            default:
                ret = EM_ERROR;
                break;
        }
        if(ret!=EM_SUCCESS)
            return EM_ERROR;
	}
    
    EG_modem_STS.hdlc_s.addr = ucSdlcAD;
    EG_modem_STS.hdlc_s.re_cnt = ucSST;
    EG_modem_STS.mode = EM_MODEM_MODE_SDLC;
    return EM_SUCCESS;
}

uchar   EA_ucSendSdlc(DevHandle hDevHandle , uint uiLen , const char *pcBuf)
{
    uchar ret;
    UNSIGNED time_cur,time_start;
    
    uprintf("API:%s %d\r\n",__FUNCTION__,uiLen);
    ret = EI_VerifyHandle_sync(hDevHandle);
	if(ret != EM_SUCCESS)
		return EM_ERRHANDLE;
	if(pcBuf==NULL||uiLen>1024)
	    return EM_ERRPARAM;
	if(EG_modem_STS.online!=EM_ONLINE_DATA)
	    return EM_ERROR;
	if (uiLen==0)
		return EM_SUCCESS;
	
	//TRACE_CONTENTS(uiLen,pcBuf);	
    time_start = NU_Retrieve_Clock();    
    while(1)
    {
        if(EG_modem_STS.online!=EM_ONLINE_DATA)
            return EM_ERROR;
        /* here we must protect the EI_SetHdlc_sendflag() and hdlc_s.resend_buf */
        NU_Obtain_Semaphore(&(EG_modem_STS.drv_api_SEM),NU_SUSPEND);
        if(EG_modem_STS.hdlc_s.send_flag==EM_HDLC_TRANSMIT_NODATA)
        {
            EI_SetHdlc_sendflag(EM_HDLC_TRANSMIT_DATA);
            EI_hdlc_send_iframe((uchar *)pcBuf,uiLen);
            NU_Release_Semaphore(&(EG_modem_STS.drv_api_SEM));
            break;
        }
        else
        {
            NU_Release_Semaphore(&(EG_modem_STS.drv_api_SEM));
            NU_Sleep(1);
        }
        time_cur = NU_Retrieve_Clock();
        if(time_cur>=time_start+EM_TIME_TICK_IN1S*10)   /* 10 seconds time out */
            return EM_ERROR;
    }    
    while(1)
    {
        if(EG_modem_STS.online!=EM_ONLINE_DATA)
            return EM_ERROR;
        if(EG_modem_STS.hdlc_s.send_flag==EM_HDLC_TRANSMIT_NODATA)
            return EM_SUCCESS;
        time_cur = NU_Retrieve_Clock();
        if(time_cur>=time_start+EM_TIME_TICK_IN1S*10)   /* 10 seconds time out */
            return EM_ERROR;
        NU_Sleep(1);
    }
}

uchar	EA_ucReadSdlc(DevHandle hDevHandle , uint uiSecond , void *pvBuf , uint *puiRealLen )
{
    uchar ret;
    unsigned int tout = 0;
    unsigned int uiRet = 0;
    UNSIGNED time_cur,time_start;
    
    uprintf("API:%s\r\n",__FUNCTION__);    
    ret = EI_VerifyHandle_sync(hDevHandle);
	if(ret != EM_SUCCESS)
		return EM_ERRHANDLE;
	if(pvBuf==NULL||puiRealLen==NULL)
		return EM_ERRPARAM;
    if(uiSecond==0||uiSecond>60)
        tout = EM_TIME_TICK_IN1S*60;
    else
        tout = EM_TIME_TICK_IN1S*uiSecond;
        
    *puiRealLen = 0;    /* do not forget it! */
    time_start = NU_Retrieve_Clock();
	while(1)
	{
	    if(EG_modem_STS.online!=EM_ONLINE_DATA)
            return EM_ERROR;
	    uiRet = loop_read(EG_modem_STS.hdlc_recvbuf,(char *)pvBuf,1024);
	    if(uiRet>0)
	    {
	        *puiRealLen = uiRet;
	        //TRACE_CONTENTS(uiRet,pvBuf);
	        return EM_SUCCESS;
	    }
	    time_cur = NU_Retrieve_Clock();
	    if(time_cur>=time_start+tout)
            return EM_SUCCESS;