at_recv.c

在ARM7和UC/OSII的平台上实现了GPS自动报站的功能,涉及GPS模块LEA_4S的驱动,位置速寻算法,语音芯片ISD4004的录放音驱动,LED页面管理等等.从启动代码到操作系统的移植以及到业

/****************************************************************
**                                                              *
**  FILE         :  AT_RECV.C                                   *
**  COPYRIGHT    :  (c) 2001 .Xiamen Yaxon NetWork CO.LTD       *
**                                                              *
**                                                              *
**  By : CCH 2002.1.15                                          *
****************************************************************/
#include "includes.h"
#include "bsp.h"
#include "hardware.h"
#include "message.h"
#include "tools.h"
#include "errtask.h"
#include "timetask.h"
#include "pdumode.h"
#include "gsmtask.h"
#include "at_core.h"
#include "at_recv.h"

#include "phonedrv.h"
#include "sm_recv.h"
#include "ZPrint.h"



/*
********************************************************************************
*                  DEFINE CONFIG PARAMETERS
********************************************************************************
*/
#define MAX_RCB                             4

#define BUFSIZE_1                           50
#define BUFSIZE_2                           512
#define BUFSIZE_3                           50


/*
********************************************************************************
*                  DEFINE COMMAND CONTROL BLOCK EVENT
********************************************************************************
*/
#define EVT_RESET                           0
#define EVT_OVERTIME                        1
#define EVT_NORMAL                          2


/*
********************************************************************************
*                  DEFINE AT COMMANDS HANDLER RETURN
********************************************************************************
*/
#define RET_CONTINUE                        0
#define RET_END                             1
#define RET_ABNORMAL                        2


/*
********************************************************************************
*                  DEFINE HANDLER TABLE STRUCTURE
********************************************************************************
*/
typedef struct {
    char    *keyword;
    INT8U    overtime;
    INT8U    (* handler)(INT8U id, INT8U event, INT8U *sptr, INT16U len);
} HDLTBL_STRUCT;


/*
********************************************************************************
*                  DEFINE COMMAND CONTROL BLOCK
********************************************************************************
*/
typedef struct {
    TMR_TSK        *overflowtmr;            /* overflow timer */
    INT16U          bufsize;                /* receive buffer size */
    INT8U          *recvbuf;                /* receive buffer pointer */
    INT8U           tblsize;                /* handler table size */
    HDLTBL_STRUCT  *hdltbl;                 /* handler table */
    INT8U           nrEC;
    INT8U           (* handler)(INT8U id, INT8U event, INT8U *sptr, INT16U len);
} RCB_STRUCT;


/*
********************************************************************************
*                  DEFINE MODULE VARIANT
********************************************************************************
*/
static RCB_STRUCT *RCB[MAX_RCB] = {NULL, NULL, NULL, NULL};


/*
********************************************************************************
*                  DEFINE AT COMMANDS HANDLER
********************************************************************************
*/
/*
********************************************************************************
* Handler: +CMT
********************************************************************************
*/

static INT8U Handler_CMT(INT8U id, INT8U event, INT8U *sptr, INT16U len)
{
    if (event == EVT_RESET) return RET_END;
    if (event == EVT_OVERTIME) {
        NotifyRecvSM();
        return RET_END;
    }

    if (RCB[id]->nrEC == 0) {
        RCB[id]->recvbuf[0] = SearchDigitalString(sptr, len, CR, 1);
        NotifyRecvSM();
        return RET_CONTINUE;
    } else if (RCB[id]->nrEC == 1) {
        NotifyRecvSM();

        if (ParsePDUData((SM_STRUCT *)RCB[id]->recvbuf, sptr, len, RCB[id]->recvbuf[0])) {
            /* add handler */
            DetectShortMessage((SM_STRUCT *)RCB[id]->recvbuf);
            OSQPost(GsmTaskMsgQue, MSG_ATRECV_RECVSHORTMSG, 0, 0);
        } else {
            #if DEBUG_UARTNo_GSMSTATUS <= 3
            PrintFromUART(DEBUG_UARTNo_GSMSTATUS, "<receive error SM>\n");
            #endif
        }
        return RET_END;
    } else {
        NotifyRecvSM();
        return RET_END;
    }
}

/*
********************************************************************************
* Handler: +CMTI
********************************************************************************
*/
static INT8U Handler_CMTI(INT8U id, INT8U event, INT8U *sptr, INT16U len)
{
    id    = id;
    event = event;
    NotifyUnReadSM(SearchDigitalString(sptr, len, ',', 1));
    return RET_END;
}

/*
********************************************************************************
* Handler: +CMGR
********************************************************************************
*/
static INT8U Handler_CMGR(INT8U id, INT8U event, INT8U *sptr, INT16U len)
{
    if (event == EVT_RESET || event == EVT_OVERTIME) return RET_END;

    if (RCB[id]->nrEC == 0) {
        RCB[id]->recvbuf[0] = SearchDigitalString(sptr, len, CR, 1);
        return RET_CONTINUE;
    } else if (RCB[id]->nrEC == 1) {
        if (ParsePDUData((SM_STRUCT *)RCB[id]->recvbuf, sptr, len, RCB[id]->recvbuf[0])) {
            DetectShortMessage((SM_STRUCT *)RCB[id]->recvbuf);
        } else {
            #if DEBUG_UARTNo_GSMSTATUS <= 3
            PrintFromUART(DEBUG_UARTNo_GSMSTATUS, "<read error SM>\n");
            #endif
        }
        return RET_END;
    } else {
        return RET_END;
    }
}

/*
********************************************************************************
* Handler: +CMGL
********************************************************************************
*/
static INT8U Handler_CMGL(INT8U id, INT8U event, INT8U *sptr, INT16U len)
{
    event = event;
    ClearWatchdog();                        /* clear watch dog */
    if (RCB[id]->nrEC == 0) {
        NotifyUnReadSM(SearchDigitalString(sptr, len, ',', 1));
        return RET_CONTINUE;
    } else {
        return RET_END;
    }
}

/*
********************************************************************************
* Handler: RING
********************************************************************************
*/
static INT8U Handler_RING(INT8U id, INT8U event, INT8U *sptr, INT16U len)
{
	id   = id;
	len  = len;
	sptr = sptr;

    if (event == EVT_NORMAL) {
        /* add handler */
        DetectRing(PHONE_COM);
    }
	return RET_END;
}

/*
********************************************************************************
* Handler: +CLIP
********************************************************************************
*/
static INT8U Handler_CLIP(INT8U id, INT8U event, INT8U *sptr, INT16U len)
{
    INT8U tellen;

    if (event == EVT_NORMAL) {
        tellen = SearchString(RCB[id]->recvbuf, RCB[id]->bufsize, sptr, len, '"', 1);
        /* add handler */
        DetectCLIP(PHONE_COM, RCB[id]->recvbuf, tellen);
    }
    return RET_END;
}

/*
********************************************************************************
* Handler: NO CARRIER
********************************************************************************
*/
static INT8U Handler_NOCARRIER(INT8U id, INT8U event, INT8U *sptr, INT16U len)
{
	sptr = sptr;
	len  = len;
	if (event == EVT_NORMAL) {
	    /* add handler */
	    if (id == DLC_GPRS)
	        DetectNoCarrier(PHONE_GPRS);
	    else if (id == DLC_PHONE)
	        DetectNoCarrier(PHONE_COM);
	}
	return RET_END;
}

/*
********************************************************************************
* Handler: +CREG
********************************************************************************
*/
static INT8U Handler_CREG(INT8U id, INT8U event, INT8U *sptr, INT16U len)
{
    INT8U stat, lac, ci;

    id = id;
    if (event == EVT_NORMAL) {
        stat = SearchDigitalString(sptr, len, ',', 1);
        lac  = SearchDigitalString(sptr, len, ',', 2);
        ci   = SearchDigitalString(sptr, len, CR,  1);
	    /* add handler */
    }
    return RET_END;
}

/*
********************************************************************************
* Handler: ^SYSSTART
********************************************************************************
*/
static INT8U Handler_SYSSTART(INT8U id, INT8U event, INT8U *sptr, INT16U len)
{
    id   = id;
    len  = len;
    sptr = sptr;
    if (event == EVT_NORMAL) {
        /* add handler */
        DetectGsmSysStart();
    }
    return RET_END;
}




/*
********************************************************************************
*                  DEFINE receive control block
********************************************************************************
*/
/* define receive control block1 */
static HDLTBL_STRUCT HdlTbl1[] = {
                                     "NO CARRIER",           2,      Handler_NOCARRIER,
                                     "BUSY",                 2,      Handler_NOCARRIER,
                                     "NO ANSWER",            2,      Handler_NOCARRIER,
                                     "NO DIALTONE",          2,      Handler_NOCARRIER
                                 };

static INT8U recvbuf_1[BUFSIZE_1];               /* RCB1 receive buffer */
static RCB_STRUCT RCB1;


/* define receive control block2 */
static HDLTBL_STRUCT HdlTbl2[] = {
                                     "+CMT:",                2,      Handler_CMT,
                                     "+CREG",                2,      Handler_CREG,
                                     "+CMTI:",               2,      Handler_CMTI,
                                     "+CMGL:",               2,      Handler_CMGL,
                                     "+CMGR:",               2,      Handler_CMGR
                                 };

static INT8U recvbuf_2[BUFSIZE_2];               /* RCB2 receive buffer */
static RCB_STRUCT RCB2;


/* define receive control block3 */
static HDLTBL_STRUCT HdlTbl3[] = {
                                     "RING",                 2,      Handler_RING,
                                     "+CLIP",                2,      Handler_CLIP,
                                     "NO CARRIER",           2,      Handler_NOCARRIER,
                                     "BUSY",                 2,      Handler_NOCARRIER,
                                     "NO ANSWER",            2,      Handler_NOCARRIER,
                                     "NO DIALTONE",          2,      Handler_NOCARRIER,
                                     "+CREG",                2,      Handler_CREG,
                                     "^SYSSTART",            2,      Handler_SYSSTART
                                 };

static INT8U recvbuf_3[BUFSIZE_3];               /* RCB3 receive buffer */
static RCB_STRUCT RCB3;




static void DestroyRCB(INT8U id)
{
    RCB[id]->handler = NULL;
    StopTmr(RCB[id]->overflowtmr);
}

static void OverflowTmrProc(void)
{
    INT8U id;

    id = GetCurTmrIndex();
    if (RCB[id]->handler != NULL) {
        RCB[id]->handler(id, EVT_OVERTIME, 0, 0);
    }
    DestroyRCB(id);
}

static void DiagnoseProc(void)
{
    INT8U i;

    for (i = 0; i < MAX_RCB; i++) {
        if (RCB[i] != NULL) {
            if (RCB[i]->handler != NULL) {
                if (GetTmrSwitch(RCB[i]->overflowtmr) != ON) ErrExit(ERR_ATRECV_TMR);
            }
        }
    }
}

void InitAT_Recv(void)
{
    INT8U i;

    /* initialize RCB1 */
    {
        RCB1.recvbuf = recvbuf_1;
        RCB1.bufsize = sizeof(recvbuf_1);
        RCB1.hdltbl  = HdlTbl1;
        RCB1.tblsize = sizeof(HdlTbl1)/sizeof(HDLTBL_STRUCT);
    }

    /* initialize RCB2 */
    {
        RCB2.recvbuf = recvbuf_2;
        RCB2.bufsize = sizeof(recvbuf_2);
        RCB2.hdltbl  = HdlTbl2;
        RCB2.tblsize = sizeof(HdlTbl2)/sizeof(HDLTBL_STRUCT);
    }

    /* initialize RCB3 */
    {
        RCB3.recvbuf = recvbuf_3;
        RCB3.bufsize = sizeof(recvbuf_3);
        RCB3.hdltbl  = HdlTbl3;
        RCB3.tblsize = sizeof(HdlTbl3)/sizeof(HDLTBL_STRUCT);
    }

    /* initialize RCB array */
    {
        RCB[0] = NULL;
        RCB[1] = &RCB1;
        RCB[2] = &RCB2;
        RCB[3] = &RCB3;
    }

    for (i = 0; i < MAX_RCB; i++) {
        if (RCB[i] != NULL) {
            RCB[i]->handler     = NULL;
            RCB[i]->overflowtmr = CreateTimer(OverflowTmrProc, i);
        }
    }
    InstallDiagProc(DiagnoseProc);
}

void ResetAT_Recv(void)
{
    INT8U i;

    for (i = 0; i < MAX_RCB; i++) {
        if (RCB[i] != NULL) {
            if (RCB[i]->handler != NULL) {
                RCB[i]->handler(i, EVT_RESET, 0, 0);
            }
            DestroyRCB(i);
        }
    }
}

BOOLEAN AT_RecvEntry(INT8U id, INT8U *sptr, INT16U len)
{
    INT8U  i;

    if (RCB[id] == NULL || len <= 3) return FALSE;
    if (RCB[id]->handler != NULL) {
        RCB[id]->nrEC++;
        if (RCB[id]->handler(id, EVT_NORMAL, sptr, len) != RET_CONTINUE) {
            DestroyRCB(id);
        }
        return TRUE;
    } else {
        for (i = 0; i < RCB[id]->tblsize; i++) {
            if (SearchKeyWordFromHead(sptr, len, RCB[id]->hdltbl[i].keyword)) {
                if (RCB[id]->hdltbl[i].handler != NULL) {
                    RCB[id]->nrEC    = 0;
                    RCB[id]->handler = RCB[id]->hdltbl[i].handler;
                    StartTmr(RCB[id]->overflowtmr, SECOND, RCB[id]->hdltbl[i].overtime);
                    if (RCB[id]->handler(id, EVT_NORMAL, sptr, len) != RET_CONTINUE) {
                        DestroyRCB(id);
                    }
                }
                return TRUE;
            }
        }
        return FALSE;
    }
}