isomodem.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"

EM_modem_STS    EG_modem_STS;
EM_modem_patch   EG_patch_Info;
extern int debug_msg;
void	EI_vOffHook(void)
{
    uprintf("%s\r\n",__FUNCTION__);
	return;
}

void	EI_vOnHook(void)
{
    uprintf("%s\r\n",__FUNCTION__);
	return;
}

void	EI_vInitMnwk(void)
{
    uprintf("%s\r\n",__FUNCTION__);
	return;
}
void	EI_vUnMnwk(void)
{
    uprintf("%s\r\n",__FUNCTION__);
	return;
}

uchar	EI_ucMnwkSendSdlc(uint uiLen,char *pcBuf)
{
	uprintf("%s\r\n",__FUNCTION__);
	return EM_ERROR;
}

void	EI_vLineToModem(void)
{
	long i = 0;
	rPDATC|=EM_MODEM_RELAY;
	for(i = 0; i < 0x10000; i++);
	return;
}
void	EI_vLineToPhone(void)
{
	long i = 0;
	rPDATC&=(~EM_MODEM_RELAY);
	for(i = 0; i < 0x10000; i++);
	return;
}

void EI_vShow(uchar show,uchar icon)
{
    switch(icon)
    {
        case EM_icon_MODEM:
            EA_vShowICONs(MODEM_ICON_X,MODEM_ICON_Y,show,EM_icon_MODEM);
            break;
        case EM_icon_ONLINE:
            EA_vShowICONs(ONLINE_ICON_X,ONLINE_ICON_Y,show,EM_icon_ONLINE);
            break;
        case EM_icon_DCD:
            EA_vShowICONs(MODEM_ICON_X,MODEM_ICON_Y,show,EM_icon_DCD);
            break;
        default:
            break;
    }
}

uchar EI_JudgeModemHandle(DevHandle hDevHandle, uchar *pucMode)
{
	char  acDeviceName[21];
	uchar ucOpenMode;
	
	memset(acDeviceName, 0x00, 21);
	EA_ucGetDeviceInfo(hDevHandle, acDeviceName, &ucOpenMode);
	
	if( !strcmp(acDeviceName, "MODEM") )
	{
		*pucMode = ucOpenMode;
		return EM_SUCCESS;
	}
	else
	{
	    uprintf("%s ERROR:not modem handle\r\n",__FUNCTION__);
		return EM_ERROR;
	}	
}

uchar	EI_VerifyHandle_asyn(DevHandle hDev)
{
	uchar ucRet = EM_SUCCESS;
	uchar ucMode;
    
    ucRet = EI_JudgeModemHandle(hDev, &ucMode);

    if(ucRet != EM_SUCCESS)
        return EM_ERROR;
	else
	{
		if(EM_io_DIAL!=ucMode)
		{
		    uprintf("%s ERROR:not asyn handle\r\n",__FUNCTION__);
			return EM_ERROR;
		}
	}

	return EM_SUCCESS;
}

uchar	EI_VerifyHandle_sync(DevHandle hDev)
{
	uchar ucRet = EM_SUCCESS;
	uchar ucMode;
    
    ucRet = EI_JudgeModemHandle(hDev, &ucMode);
    if(ucRet != EM_SUCCESS)       
        return EM_ERROR;
	else
	{
		if(EM_io_SDLC!=ucMode)
		{
		    uprintf("%s ERROR:not sync handle\r\n",__FUNCTION__);
			return EM_ERROR;
		}
	}
    
	return EM_SUCCESS;
}

uchar	EI_VerifyHandle_ppp(DevHandle hDev)
{
    uchar ucRet = EM_SUCCESS;
	uchar ucMode;
	
	ucRet = EI_JudgeModemHandle(hDev, &ucMode);

    if(ucRet != EM_SUCCESS)
        return EM_ERROR;
	else
	{
		if(EM_io_PPP!=ucMode)
		{
		    uprintf("%s ERROR:not ppp handle\r\n",__FUNCTION__);
			return EM_ERROR;
		}
	}

	return EM_SUCCESS;
}

uchar EI_GetDevType(void)
{
    uint uiItemNumber;
	ET_BASE_CONFIG_ITEM tBaseCfg;
	uchar ucRet;

    ucRet = EA_ucSearchInBaseConfig("机器类型",&uiItemNumber,&tBaseCfg);
	if(ucRet!=EM_SUCCESS)
	{
		uprintf("Get device type failed in EA_ucEnetInit()\r\n");
		return EM_ERROR;		//获取配置表信息错误
	}
	if( *((char *)(tBaseCfg.acDriverIndex)) == '0' )
	{
	    uprintf("dev:not hand\r\n");
	    EG_modem_STS.dev = DEV_NOTHAND;//台式机	    
	}
	else
	{
	    uprintf("dev:hand\r\n");
	    EG_modem_STS.dev = DEV_HAND;//手持机
	}
	return EM_SUCCESS;
}

int EI_modem_init(void)
{
    STATUS iStatus=NU_SUCCESS;
    
    memset((char *)&EG_modem_STS,0x00,sizeof(EG_modem_STS));
    
    if(EI_GetDevType()!=EM_SUCCESS)
        return EM_ERROR;
    if(EI_JudegModem()!=EM_SUCCESS)
        return EM_ERROR;
    /* mem alloc */
    EG_modem_STS.serial_recvbuf = (_loopbuf *)EA_pvMalloc(sizeof(_loopbuf));
    EG_modem_STS.v80_recvbuf = (_loopbuf *)EA_pvMalloc(sizeof(_loopbuf));
    EG_modem_STS.hdlc_recvbuf = (_loopbuf *)EA_pvMalloc(sizeof(_loopbuf));
    if(EG_modem_STS.serial_recvbuf==EM_NULL
        ||EG_modem_STS.v80_recvbuf==EM_NULL
        ||EG_modem_STS.hdlc_recvbuf==EM_NULL
        )
    {
        TRACE("ERROR: %s %s malloc fail\n",__FUNCTION__,__LINE__);
        return EM_ERROR;
    }
    if(loop_init(EG_modem_STS.serial_recvbuf,"MdmSerialRecv",16*1024,EM_LOOPBUF_THREAD_THREAD)!=EM_SUCCESS
        ||loop_init(EG_modem_STS.v80_recvbuf,"MdmV80Recv",MAX_SDLC_FRAME_LEN*2,EM_LOOPBUF_THREAD_THREAD)!=EM_SUCCESS
        ||loop_init(EG_modem_STS.hdlc_recvbuf,"MdmHdlcRecv",MAX_SDLC_FRAME_LEN,EM_LOOPBUF_THREAD_THREAD)!=EM_SUCCESS  
        )
    {
        TRACE("ERROR: %s %s loop_init fail\n",__FUNCTION__,__LINE__);
        return EM_ERROR;
    }
    uprintf("mem alloc ok\r\n");
    /* semaphore init */    
    if(NU_Create_Semaphore(&(EG_modem_STS.drv_api_SEM),"DRV_API_SEM",1, NU_FIFO)!=NU_SUCCESS
        ||NU_Create_Semaphore(&(EG_modem_STS.serial_SEM),"SERIAL_SEM",1, NU_FIFO)!=NU_SUCCESS
        )
    {
		return EM_ERROR;
    }
    
    uprintf("sem alloc ok\r\n");
    /* mailbox init */
    if(NU_Create_Mailbox(&(EG_modem_STS.serial_MB),"SERIAL_MB",NU_FIFO)!=NU_SUCCESS)
	{
		return EM_ERROR;
	}
	uprintf("mailbox alloc ok\r\n");
    /* task init */
#define EM_TASK_MEM_SIZE    1024*64
#define EM_TASK_SERIAL_PRIORITY     98
#define EM_TASK_SERIAL_SLICE    (UNSIGNED)(1)    
    EG_modem_STS.pTaskSerailMem=EA_pvMalloc(EM_TASK_MEM_SIZE);
    if(EG_modem_STS.pTaskSerailMem==EM_NULL)
        return EM_ERROR;
	iStatus = NU_Create_Task(&(EG_modem_STS.serial_TASK), "TASKSERIAL",
		EI_vSerialTask_new, 0, NU_NULL,
		EG_modem_STS.pTaskSerailMem,
		EM_TASK_MEM_SIZE,
		EM_TASK_SERIAL_PRIORITY,
		EM_TASK_SERIAL_SLICE,
		NU_PREEMPT, NU_START);
	if(iStatus != NU_SUCCESS)
    {
        TRACE("ERROR: %s %s create task fail\n",__FUNCTION__,__LINE__);
		return EM_ERROR;
    }
    uprintf("task alloc ok\r\n");
    NU_Create_Timer(&(EG_modem_STS.timer_10ms),"T_MODEM_10MS",EI_DetectRing,1,25,1,NU_ENABLE_TIMER);
    EI_SetModemOnline(EM_ONLINE_AT);
    EG_modem_STS.max_time_toconnect = 30;
    EG_modem_STS.max_time_todata    = 10;
    return EM_SUCCESS;
}

void EI_vSerialTask_new(UNSIGNED argc, VOID *argv)
{
    uchar   ucRXData=0;
    uint    uiActlength;
    uchar   ucRet;
    unsigned int	tMsg[4];
        
sleep:
    NU_Receive_From_Mailbox(&(EG_modem_STS.serial_MB),tMsg,NU_SUSPEND);
    while(1)
    {
        /*{
            UNSIGNED time_cur;
            time_cur = NU_Retrieve_Clock();
            uprintf("{%d}\r\n",time_cur);
        }*/ 
        ucRet = EA_ucReadDeviceMs(EG_modem_STS.uarthandle,1,100,&ucRXData,&uiActlength);
        NU_Obtain_Semaphore(&(EG_modem_STS.drv_api_SEM),NU_SUSPEND);
        if(ucRet==EM_SUCCESS)
        {
            if(uiActlength==1)
            {
#ifdef DEBUG_MODEM_RECV
                uprintf("<%2.2x> ",ucRXData);
#endif
                switch(EG_modem_STS.online)
                {
                    case EM_ONLINE_CONNECTED:
                    case EM_ONLINE_DATA:
                        if(EG_modem_STS.mode==EM_MODEM_MODE_SDLC)
                            EI_hdlc_receive_v80tohdlc(ucRXData);
                        else if(EG_modem_STS.mode==EM_MODEM_MODE_PPP)
                        {
                            loop_write(EG_modem_STS.serial_recvbuf,(char *)&ucRXData,1);
                            EA_ppp_vHandle();
                        }
                        else
                            loop_write(EG_modem_STS.serial_recvbuf,(char *)&ucRXData,1);
                        break;
                    case EM_ONLINE_DIALING:                        
                        EI_DialingResp(ucRXData);
                        break;
                    default:
                        loop_write(EG_modem_STS.serial_recvbuf,(char *)&ucRXData,1);
                        break;
                }                
            }
            else
            {
            }
        }
        else
        	NU_Sleep(10); 
        EI_DialingTout();
        EI_Dcd();
        NU_Release_Semaphore(&(EG_modem_STS.drv_api_SEM));
        if(EG_modem_STS.sleep_state==SLEEP_STATE_TO_SLEEP_UART_TASK) 
        {
        	EG_modem_STS.sleep_state = SLEEP_STATE_NO_NEED;
            uprintf("SERIAL TASK SLEEP\r\n");
            goto sleep;
        }
    }
}

void	EI_DetectRing(UNSIGNED id)
{
    /* 
     * 这个必须放在时钟软中断中作，因为如果放在读串口的后台进程中做的话，可能100ms才能检查一次，
     * 这样可能会导致检测失败
     * RI输出的振铃响应波形是低脉宽13～18ms、高脉宽2～7ms的连续脉冲波，持续时间和振铃时间一致。
    */
    UNSIGNED    time_cur;
    
    time_cur = NU_Retrieve_Clock();
    if((rPDATD & RING_BIT)==0)
    {
        if(EG_modem_STS.ring_cnt==0)
        {
            /* set the first time we detect the ring */
            EG_modem_STS.ring_start = NU_Retrieve_Clock();
        }
        EG_modem_STS.ring_cnt++;
        if(EG_modem_STS.ring_cnt>2
            &&EG_modem_STS.ring_start!=0
            &&time_cur>=EG_modem_STS.ring_start+EM_TIME_TICK_IN1S/10)
        {
            /* 在100ms内检测到2次以上的RING表示有效 */
            EG_modem_STS.ring_detect = EM_SUCCESS;
        }
    }
    else
    {
        /* 在第一次检测到有效电平后的2s后，如果电平无效，认为没有RING */
        if(time_cur>=EG_modem_STS.ring_start+EM_TIME_TICK_IN1S*2)
        {
            EG_modem_STS.ring_detect = EM_ERROR;
            EG_modem_STS.ring_cnt = 0;
            EG_modem_STS.ring_start = 0;
        }
    }
}

void EI_Dcd(void)
{
    if(EG_modem_STS.online==EM_ONLINE_DATA)
    {
        if((rPDATD & DCD_BIT)!=0)	//低电平有效
        {
            uprintf("WARN:LOST DCD\r\n");
            EI_ModemOffline();
        }
    }
}

void EI_DialingResp(uchar data)
{
    UNSIGNED time_cur;
    
    time_cur = NU_Retrieve_Clock();    
    if(EG_modem_STS.dialing_buf_len>=sizeof(EG_modem_STS.dialing_buf)-1)
    {
        uprintf("ERROR:dialing buf overflow\r\n");
        return;
    }
    EG_modem_STS.dialing_buf[EG_modem_STS.dialing_buf_len++] = data;    
    if(strstr(EG_modem_STS.dialing_buf,"CONNECT"))
    {