gprsrecv.c

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

/****************************************************************
**                                                              *
**  FILE         :  GPRSRecv.C                                  *
**  COPYRIGHT    :  (c) 2001 .Xiamen Yaxon NetWork CO.LTD       *
**                                                              *
**                                                              *
**  By : CCH 2003.4.18                                          *
****************************************************************/
#include "includes.h"
#include "bsp.h"
#include "message.h"
#include "tools.h"
#include "roundbuf.h"
#include "gsmtask.h"
#include "rx_frame.h"
#include "gprsdrv.h"


/*
********************************************************************************
*                  DEFINE CONFIG PARAMETERS
********************************************************************************
*/
#define NUM_RCB                         3
#define SIZE_TCPBUF                     1024
#define SIZE_UDPBUF                     1024
#define SIZE_IVUDPBUF                   2048
#define SIZE_HDLBUF                     1024


/*
********************************************************************************
*                  DEFINE IVUDP_STRUCT
********************************************************************************
*/
typedef struct {
    INT8U        chksum;
    INT8U        prio;
    INT8U        type;
    INT8U        len[2];
    INT8U        data[1];
} IVUDP_STRUCT;

/*
********************************************************************************
*                  DEFINE UDP_STRUCT
********************************************************************************
*/
typedef struct {
    INT8U        chksum;
    INT8U        prio;
    INT8U        type;
    INT8U        data[1];
} UDP_STRUCT;

/*
********************************************************************************
*                  DEFINE TCP_STRUCT
********************************************************************************
*/
typedef struct {
    INT8U        chksum;
    INT8U        prio;
    INT8U        type;
    INT8U        data[1];
} TCP_STRUCT;

/*
********************************************************************************
*                  DEFINE RCB_STRUCT
********************************************************************************
*/
typedef struct {
    INT8U          *bufptr;
    INT16U          bufsize;
    INT16U          recvlen;
    ROUNDBUF_STRUCT recvround;
} RCB_STRUCT;



/*
********************************************************************************
*                  DEFINE MODULE VARIANT
********************************************************************************
*/

static ASMRULE_STRUCT rules = {0x7e, 0x7d, 0x02, 0x01};
static INT8U  TCPRecvBuf[SIZE_TCPBUF];
static INT8U  UDPRecvBuf[SIZE_UDPBUF];
static INT8U  IVUDPRecvBuf[SIZE_IVUDPBUF];
static INT8U  hdlrecvbuf[SIZE_HDLBUF];

static RCB_STRUCT RCB[NUM_RCB];



/*
********************************************************************************
*                  DEFINE MESSAGE HANDLER
********************************************************************************
*/
static void HdlMsg_0x81(INT8U channel, INT8U *data, INT16U datalen)
{
    channel = channel;
    data    = data;
    datalen = datalen;
}

static void HdlMsg_0x82(INT8U channel, INT8U *data, INT16U datalen)
{
    channel = channel;
    data    = data;
    datalen = datalen;
    if (*data != 0x02) return;
    if (channel == CHA_UDP) {
        Informer_UDPLinkInexist();
    } else if (channel == CHA_TCP) {
        Informer_TCPLinkInexist();        
    }
}

static void HdlMsg_0x83(INT8U channel, INT8U *data, INT16U datalen)
{
    channel = channel;
    data    = data;
    datalen = datalen;
    if (channel == CHA_TCP)
        DetectSysFrame(RX_FRAME_TCP, datalen, (SYSFRAME_STRUCT *)data);
    else if (channel == CHA_UDP)
        DetectSysFrame(RX_FRAME_UDP, datalen, (SYSFRAME_STRUCT *)data);
}

static void HdlMsg_0x84(INT8U channel, INT8U *data, INT16U datalen)
{
    channel = channel;
    data    = data;
    datalen = datalen;
    if (channel == CHA_TCP) 
        InformMsg_QueryTCP(data[0]);
    else if (channel == CHA_UDP)
        InformMsg_QueryUDP(data[0]);
}

static void HdlMsg_0x85(INT8U channel, INT8U *data, INT16U datalen)
{
    channel = channel;
    data    = data;
    datalen = datalen;

    if (channel == CHA_IV_UDP) {
        if (data[0] == 0x01 || data[0] == 0x02) InformMsg_IVUDPComLoged();
    }
}

static void HdlMsg_0x86(INT8U channel, INT8U *data, INT16U datalen)
{
    channel = channel;
    data    = data;
    datalen = datalen;
    if (channel == CHA_IV_UDP) InformMsg_IVUDPComDelink();
}

static void HdlMsg_0x87(INT8U channel, INT8U *data, INT16U datalen)
{
    channel = channel;
    data    = data;
    datalen = datalen;
    if (channel == CHA_IV_UDP && data[0] == 0x02) Informer_IVUDPLinkInexist();
}

static void HdlMsg_0x91(INT8U channel, INT8U *data, INT16U datalen)
{
    channel = channel;
    data    = data;
    datalen = datalen;
    if (channel == CHA_TCP)
        InformMsg_TCPLoged();
    else if (channel == CHA_UDP)
        InformMsg_UDPComLoged();
}


void InitGPRSRecv(void)
{
    RCB[CHA_TCP].bufptr     = TCPRecvBuf;
    RCB[CHA_TCP].bufsize    = sizeof(TCPRecvBuf);
    InitRoundBuf(&RCB[CHA_TCP].recvround, RCB[CHA_TCP].bufptr, RCB[CHA_TCP].bufsize, &rules);
    
    RCB[CHA_UDP].bufptr     = UDPRecvBuf;
    RCB[CHA_UDP].bufsize    = sizeof(UDPRecvBuf);
    RCB[CHA_UDP].recvlen    = 0;
    
    RCB[CHA_IV_UDP].bufptr  = IVUDPRecvBuf;;
    RCB[CHA_IV_UDP].bufsize = sizeof(IVUDPRecvBuf);
    RCB[CHA_IV_UDP].recvlen = 0;
}

void InformGPRSRecv(INT8U channel, INT8U *data, INT16U datalen)
{
    if (channel < NUM_RCB) {
        if (channel == CHA_TCP) {
            WriteBlockRoundBuf(&RCB[CHA_TCP].recvround, data, datalen);
        } else {
            if (datalen <= RCB[channel].bufsize) {
                RCB[channel].recvlen = datalen;
                memcpy(RCB[channel].bufptr, data, datalen);
            }
        }
        OSQPost(GsmTaskMsgQue, MSG_GPRSRECV_TSK, 0, 0);
    }
}

void GPRSRecvEntry(void)
{
    void   *curframe;
    INT16U hdllen, datalen;
    INT8U  i, chksum, type, *data;

    curframe = hdlrecvbuf;
    for (i = 0; i < NUM_RCB; i++) {
        switch(i)
        {
            case CHA_TCP:
                hdllen  = DeassembleRoundBuf(&RCB[CHA_TCP].recvround, hdlrecvbuf, sizeof(hdlrecvbuf));

                chksum  = ((TCP_STRUCT *)curframe)->chksum;
                type    = ((TCP_STRUCT *)curframe)->type;
                data    = ((TCP_STRUCT *)curframe)->data;
                datalen = hdllen - (sizeof(TCP_STRUCT) - 1);
                break;
            case CHA_UDP:
                if (RCB[CHA_UDP].recvlen == 0) continue;
                if (sizeof(hdlrecvbuf) < RCB[CHA_UDP].recvlen) {
                    RCB[CHA_UDP].recvlen = 0;
                    continue;
                }
                
                hdllen = RCB[CHA_UDP].recvlen;
                memcpy(hdlrecvbuf, RCB[CHA_UDP].bufptr, hdllen);
                RCB[CHA_UDP].recvlen = 0;

                chksum  = ((UDP_STRUCT *)curframe)->chksum;
                type    = ((UDP_STRUCT *)curframe)->type;
                data    = ((UDP_STRUCT *)curframe)->data;
                datalen = hdllen - (sizeof(UDP_STRUCT) - 1);
                break;
            case CHA_IV_UDP:
                if (RCB[CHA_IV_UDP].recvlen == 0) continue;
                hdllen = DeassembleByRules(hdlrecvbuf, RCB[CHA_IV_UDP].bufptr + 1, RCB[CHA_IV_UDP].recvlen - 2, &rules);
                RCB[CHA_IV_UDP].recvlen = 0;
                
                chksum  = ((IVUDP_STRUCT *)curframe)->chksum;
                type    = ((IVUDP_STRUCT *)curframe)->type;
                data    = ((IVUDP_STRUCT *)curframe)->data;
                datalen = hdllen - (sizeof(IVUDP_STRUCT) - 1);
                break;
            default:
                break;
        }
        
        if (hdllen >= 3) {
            #if DEBUG_UARTNo_GSMSTATUS <= 3
            PrintFromUART(DEBUG_UARTNo_GSMSTATUS, "<receive a frame from GPRS>\n");
            #endif
            if (GetChkSum_C(hdlrecvbuf + 1, hdllen - 1) == chksum) {
                switch(type) {
                    case 0x81:
                        HdlMsg_0x81(i, data, datalen);
                        break;
                    case 0x82:
                        HdlMsg_0x82(i, data, datalen);
                        break;
                    case 0x83:
                        HdlMsg_0x83(i, data, datalen);
                        break;
                    case 0x84:
                        HdlMsg_0x84(i, data, datalen);
                        break;
                    case 0x85:
                        HdlMsg_0x85(i, data, datalen);
                        break;
                    case 0x86:
                        HdlMsg_0x86(i, data, datalen);
                        break;
                    case 0x87:
                        HdlMsg_0x87(i, data, datalen);
                        break;
                    case 0x91:
                        HdlMsg_0x91(i, data, datalen);
                        break;
                    default:
                        break;
                }
            } else {
                #if DEBUG_UARTNo_GSMSTATUS <= 3
                PrintFromUART(DEBUG_UARTNo_GSMSTATUS, "<sorry, check sum error(GPRS)>\n");
                #endif
            }
            OSQPost(GsmTaskMsgQue, MSG_GPRSRECV_TSK, 0, 0);
        }
    }
}