isomodem.c

来自「modem数据通信源码」· C语言 代码 · 共 1,948 行 · 第 1/5 页

C
1,948
字号
        if(EG_modem_STS.mode==EM_MODEM_MODE_ASYS)
        {
            /* 在异步下,需要把这最后的\x0d\x0a滤掉 */
            if(EI_CalcCrLf(EG_modem_STS.dialing_buf)>=2)
            {
                uprintf("connect time %d ms\r\n",(time_cur-EG_modem_STS.dial_start)*10);
                EG_modem_STS.dial_connect = NU_Retrieve_Clock();
                EI_ModemConnect();
            }
            else
            {
                /* 在收到CONNECT后的200ms后,即使没有收到2个\x0d\x0a,也认为已经在线 */
                if(EG_modem_STS.dial_connect==0)
                    EG_modem_STS.dial_connect = NU_Retrieve_Clock();
                if(time_cur>=EG_modem_STS.dial_connect+EM_TIME_TICK_IN1S/5)
                {
                    uprintf("connect time %d ms\r\n",(time_cur-EG_modem_STS.dial_start)*10);
                    EI_ModemConnect();
                }
            }   
        }
        else
        {
            EG_modem_STS.dial_connect = NU_Retrieve_Clock();
            uprintf("connect time %d ms\r\n",(time_cur-EG_modem_STS.dial_start)*10);
            EI_ModemConnect();
        }  
             
    }
    else
    {
        if(strstr(EG_modem_STS.dialing_buf,"NO CARRIER"))
        {
            uprintf("dial resp:%s",EG_modem_STS.dialing_buf);
            EG_modem_STS.dial_err = EM_DIALERR_NOCARRIER;
            EI_ModemOffline();
        }
        else if(strstr(EG_modem_STS.dialing_buf,"NO ANSWER"))
        {
            uprintf("dial resp:%s",EG_modem_STS.dialing_buf);
            EG_modem_STS.dial_err = EM_DIALERR_NOANSWER;
            EI_ModemOffline();
        }
        else if(strstr(EG_modem_STS.dialing_buf,"NO DIALTONE"))
        {
            uprintf("dial resp:%s",EG_modem_STS.dialing_buf);
            EG_modem_STS.dial_err = EM_DIALERR_NODIALTONE;
            EI_ModemOffline();
        }
        else if(strstr(EG_modem_STS.dialing_buf,"BUSY"))
        {
            uprintf("dial resp:%s",EG_modem_STS.dialing_buf);
            EG_modem_STS.dial_err = EM_DIALERR_BUSY;
            EI_ModemOffline();
        }
        else if(strstr(EG_modem_STS.dialing_buf,"LINE IN USE")
                ||strstr(EG_modem_STS.dialing_buf,"ERROR")
                ||strstr(EG_modem_STS.dialing_buf,"NO LINE")
                ||strstr(EG_modem_STS.dialing_buf,"UN-OBTAINABLE NUMBER")
                )
        {
            uprintf("dial resp:%s",EG_modem_STS.dialing_buf);
            EG_modem_STS.dial_err = EM_DIALERR_ELSE;
            EI_ModemOffline();
        }
        if(EI_CalcCrLf(EG_modem_STS.dialing_buf)>=2)
        {
            /* more than 2 \x0d\x0a,not connect */
            uprintf("dial resp:%s",EG_modem_STS.dialing_buf);
            EG_modem_STS.dial_err = EM_DIALERR_ELSE;
            EI_ModemOffline();
        }              
    }
}

void EI_DialingTout(void)
{
    UNSIGNED time_cur;
    
    time_cur = NU_Retrieve_Clock();
    switch(EG_modem_STS.online)
    {
        case EM_ONLINE_CONNECTED:
            if(time_cur>=EM_TIME_TICK_IN1S*EG_modem_STS.max_time_todata+EG_modem_STS.dial_connect)
            {
                uprintf("ERROR:SNRM TIMEOUT\r\n");
                EG_modem_STS.dial_err = EM_DIALERR_TIMEOUT;
                EI_ModemOffline();                
            }
            break;
        case EM_ONLINE_DIALING:                        
            if(time_cur>=EM_TIME_TICK_IN1S*EG_modem_STS.max_time_toconnect+EG_modem_STS.dial_start)
            {
                uprintf("ERROR:CONNECT TIMEOUT\r\n");
                EG_modem_STS.dial_err = EM_DIALERR_TIMEOUT;
                EI_ModemOffline();                
            }
            break;
        default:
            break;
    }
}

void EI_ModemConnect(void)
{
    uprintf("%s\r\n",__FUNCTION__);
    loop_reset(EG_modem_STS.serial_recvbuf);
    loop_reset(EG_modem_STS.v80_recvbuf);
    loop_reset(EG_modem_STS.hdlc_recvbuf);
    switch(EG_modem_STS.mode)
    {
        case EM_MODEM_MODE_SDLC:
            EI_Init_v80();
            EI_Init_hdlc();
            EI_SetModemOnline(EM_ONLINE_CONNECTED);
            EI_vShow(EM_icon_SHOW,EM_icon_DCD);                       
            break;
        case EM_MODEM_MODE_ASYS:
            EI_SetModemOnline(EM_ONLINE_DATA);
            EI_vShow(EM_icon_SHOW,EM_icon_DCD);
            EI_vShow(EM_icon_SHOW,EM_icon_ONLINE);
            break;
        case EM_MODEM_MODE_PPP:
            EI_SetModemOnline(EM_ONLINE_DATA);
            EI_vShow(EM_icon_SHOW,EM_icon_DCD);
            EI_ModemStartPpp();
            break;
    }    
}

void EI_ModemOffline(void)
{
    /* don't call it in API,because it don't protect EI_SetModemOnline() */
    uprintf("%s\r\n",__FUNCTION__);
    EI_SetModemOnline(EM_ONLINE_OFFLINE);
    EI_vShow(EM_icon_HIDDEN,EM_icon_ONLINE);
	EI_vShow(EM_icon_HIDDEN,EM_icon_DCD);
	EI_vShow(EM_icon_HIDDEN,EM_icon_MODEM);
}

int EI_JudegModem(void)
{
    uint uiModuleID = 0;
	ET_ConfigInfo ConfigInfo;
    uchar   ucRet;
    
    EG_modem_STS.modem = EM_MODEM_UNKNOWN;
    ucRet = EA_ucGetConfig(&uiModuleID);
    if(ucRet != EM_SUCCESS)
    {
        uprintf("ERROR:Not get config\r\n");
        return EM_ERROR;
    }

    if((uiModuleID & EM_CID_MODEM) == EM_CID_MODEM)
    {
    	ucRet = EA_ucGetConfigInfo(EM_CID_MODEM, &ConfigInfo);
    	if( ucRet != EM_SUCCESS )
    	    return EM_ERROR;
    	    
        switch( ConfigInfo.cDriverIndex )
        {
            case 0x30:
                uprintf("Get modem type: SI\r\n");
				EG_modem_STS.modem = EM_MODEM_SI;
                break ;
            case 0x31:
                uprintf("Get modem type: CX\r\n");
				EG_modem_STS.modem = EM_MODEM_CX;
                break ;
            case 0x32:
                uprintf("Get modem type: CX\r\n");
				EG_modem_STS.modem = EM_MODEM_CX;
                break ;
            case 0x33:
                uprintf("Get modem type: SI\r\n");
				EG_modem_STS.modem = EM_MODEM_SI;
                break ;
            default:
                uprintf("ERROR:Get modem type unknown\r\n");
                EG_modem_STS.modem = EM_MODEM_UNKNOWN;
                break ;
        }
    }
    else
    {
        uprintf("ERROR:NOT Modem Config\r\n");
        EG_modem_STS.modem = EM_MODEM_UNKNOWN;
        return EM_ERROR;
    }
    
	return EM_SUCCESS;
}

void EI_SetModemRTS(void)
{
    INT int_level=0;
    
    int_level = NU_Local_Control_Interrupts(NU_DISABLE_IRQ);
    EG_modem_STS.UMCOM1Bak = rUMCON1;
    rUMCON1=SD_UMCON_DISABLE|SD_UMCON_RTS;    
    NU_Local_Control_Interrupts(int_level);
}

void EI_StartTaskSerail(void)
{
    unsigned int	tMsg[4];
    
    NU_Send_To_Mailbox( &(EG_modem_STS.serial_MB),tMsg,NU_NO_SUSPEND );    
}

int EI_OpenSerial(void)
{
    uchar ucRet;
    DevHandle hTemp;
    ucRet = EA_ucOpenDevice("UART1",EM_uart_MODEM,&hTemp);
    if(ucRet!=EM_SUCCESS)
	{
	    uprintf("ERROR %s open serial fail!\n",__FUNCTION__);        	    
	    return ucRet;
	}
	EG_modem_STS.uarthandle = hTemp;
	EA_ucInitRS232(hTemp, EM_232_115200BPS, EM_232_NOPAR, EM_232_8DBS);
	EI_SetModemRTS();
    NU_Sleep(10);		
	EI_StartTaskSerail();
	
	return EM_SUCCESS;		
}

int EI_StopSerial(void)
{
    INT int_level=0;    
    uprintf("%s \n",__FUNCTION__);
    
    EG_modem_STS.sleep_state = SLEEP_STATE_TO_SLEEP_UART_TASK;
    
    int_level = NU_Local_Control_Interrupts(NU_DISABLE_IRQ);    
    rUMCON1=EG_modem_STS.UMCOM1Bak;
    NU_Local_Control_Interrupts(int_level);
    
    NU_Obtain_Semaphore(&(EG_modem_STS.serial_SEM),NU_SUSPEND);
    EA_ucCloseDevice(&EG_modem_STS.uarthandle);
    NU_Release_Semaphore(&(EG_modem_STS.serial_SEM));  
    
    EI_vIntoPowerSave();      
    uprintf("%s over\n",__FUNCTION__);
    return EM_SUCCESS;
}

void EI_SetModemOnline(unsigned int online)
{
    EG_modem_STS.online = online;
}

uchar   EI_PatchModem(void)
{
    switch(EG_modem_STS.modem)
    {
        case EM_MODEM_CX:
            if(EI_PatchCx(&EG_patch_Info)!=EM_SUCCESS)
                return EM_ERROR;   
            break;
        case EM_MODEM_SI:
            if(EI_PatchSi(&EG_patch_Info)!=EM_SUCCESS)
                return EM_ERROR;
            break;
        default:
            return EM_ERROR;
    }
    return EM_SUCCESS;
}

uchar	EI_Ifexistdialtone(void)
{
	uchar		vol;
	int			iEcho=0;
	float		fEcho=0;
	
	switch(EG_modem_STS.modem)
    {
        case EM_MODEM_CX:
            if(EI_cx_AT_TRV(&fEcho)!=EM_SUCCESS)
                return EM_ERROR;
    		if((fEcho>2)&&(fEcho<12))
    			return EM_modem_PHONEINUSE;
    		else if(fEcho<2)
    		    return EM_modem_NODIALTONE;
    		else
    			return EM_SUCCESS;
        case EM_MODEM_SI:
            if(EI_si_AT_R6C(&iEcho)!=EM_SUCCESS)
    			return EM_ERROR;
    		vol = iEcho >> 8;
    		vol = ~vol;
    		vol += 1;
    		iEcho = vol;
    		
    		if((iEcho<0x10)&&(iEcho>0x03))
    			return EM_modem_PHONEINUSE;
    		else if(iEcho<0x03)
    		    return EM_modem_NODIALTONE;
    		else
    			return EM_SUCCESS;
        default:
            return EM_ERROR;
    }	
}

uchar   EI_ActiveModem(void)
{
    uchar ret;
    switch(EG_modem_STS.modem)
    {
        case EM_MODEM_CX:
            EI_SendAT("A");     /* send first 'A' to active modem in stop mode */
            NU_Sleep(3);
            ret = EI_SendAT_OK("ATS24=0\r",1);
            break;
        case EM_MODEM_SI:
            if(EG_modem_STS.dev==DEV_HAND)
                ret = EI_ResetModem();            
            else        
                ret = EI_SendATE0_OK();
            break;
        default:
            ret = EM_ERROR;
            break;
    }
    return ret;
}

uchar   EI_ResetModem(void)
{    
    int state = 0;
    UNSIGNED time_start,time_cur;
    INT int_level=0;
    
    uprintf("RESET:%s\r\n",__FUNCTION__);
    
    rPDATC&=(~EM_MODEM_RST);
	NU_Sleep(2);
	rPDATC|=EM_MODEM_RST;
	
    time_start = NU_Retrieve_Clock();
    time_cur = NU_Retrieve_Clock();     /* 为了去掉编译警告 */
    switch(EG_modem_STS.modem)
    {
        case EM_MODEM_CX:
            while(1)
        	{
        	    time_cur = NU_Retrieve_Clock();	    
        	    if(time_cur>=time_start+EM_TIME_TICK_IN1S)       //1s
        	        break;
        	    // CTS先低120ms、再高180ms左右、再低
        	    if((rUMSTAT1 & 0x1)==0&&state==0)
        	        state = 1;
        	    if((rUMSTAT1 & 0x1)!=0&&state==1)
        	        state = 2;
        	    if((rUMSTAT1 & 0x1)==0&&state==2)
        	        break;
        	}
            break;
        case EM_MODEM_SI:
            NU_Sleep(30);       /* data sheet require */
            time_cur = NU_Retrieve_Clock();
            break;
        default:
            NU_Sleep(30);
            time_cur = NU_Retrieve_Clock();
            break;
    }
    int_level = NU_Local_Control_Interrupts(NU_DISABLE_IRQ);
	uprintf("reset cost %d ms\r\n",(time_cur-time_start)*10);
	NU_Local_Control_Interrupts(int_level);
	return EM_SUCCESS;
}

uchar   EA_MODEM_ucDrvOpen(void)
{
    uint uiStatus;
    int ret;
    
    uprintf("\r\n");
    uprintf("MODEM DIRVER VERSION: 03-07-03\r\n");    
    uprintf("\r\n");
#ifdef  NEW_OS
    if (EA_ucDrvIsInitialized(EM_IS_INIT_MODEM, &uiStatus) == EM_SUCCESS)
    {
    	if (uiStatus == EM_DRV_INIT_SUCC)

⌨️ 快捷键说明

复制代码Ctrl + C
搜索代码Ctrl + F
全屏模式F11
增大字号Ctrl + =
减小字号Ctrl + -
显示快捷键?