socktask.c

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

/****************************************************************
**                                                              *
**  FILE         :  SockTask.C                                  *
**  COPYRIGHT    :  (c) 2001 .Xiamen Yaxon NetWork CO.LTD       *
**                                                              *
**                                                              *
**  By : CCH 2002.1.15                                          *
****************************************************************/
#include "includes.h"
#include "bsp.h"
#include "message.h"
#include "tools.h"
#include "ipport.h"
#include "mtcp.h"
#include "q.h"
#include "gsmtask.h"
#include "gprsrecv.h"
#include "socktask.h"
#include "watchdog.h"
#include "printer.h"



/*
********************************************************************************
*                  DEFINE CONFIG PARAMETERS
********************************************************************************
*/
#define SIZE_MSGBUF             20
#define MEM_SIZE                2048
#define MAX_WAIT_SEND           (120 * 20)                   /* MAX_WAIT_SEND = 120 second */
#define MAX_WAIT_ERR            (15 * 60 * 20)               /* MAX_WAIT_ERR  = 15 m */



/*
********************************************************************************
*                  DEFINE s_status
********************************************************************************
*/
#define S_CLOSED                0
#define S_OPENED                1
#define S_OPENING               2
#define S_CLOSING               3


/*
********************************************************************************
*                  DEFINE MODULE VARIANT
********************************************************************************
*/
static OS_EVENT *MsgQue;
static OS_QMSG   CurMsg;
static OS_QMSG   MsgBuf[SIZE_MSGBUF];
static OS_STK    SockTaskStack[STACK_SOCKTASK];

static M_SOCK    c_sock;
static INT8U     s_state = S_CLOSED;
static INT16U    ct_sendwait;
static INT16U    sendlen;
static INT8U     sendmem[MEM_SIZE];

static char      host_ipaddr[20], host_ipport[10];

extern queue     bigfreeq;    /* big free buffers */
extern queue     lilfreeq;    /* small free buffers */

static INT8U     wdgid;



static int CallbackProc(int code, M_SOCK so, void *data)
{
    PACKET pkt;

    pkt = (PACKET)data;
    switch(code)
    {
        case M_OPENOK:
            #if DEBUG_UARTNo_SOCKET <= 3
            PrintFromUART(DEBUG_UARTNo_SOCKET, "M_OPENOK!\n");
            #endif
            if (s_state == S_OPENING && so == c_sock) {
                #if DEBUG_UARTNo_SOCKET <= 3
                PrintFromUART(DEBUG_UARTNo_SOCKET, "<socket is opened>\n");
                #endif
                s_state = S_OPENED;

                /* send message to gsmtask */
                OSQPost(GsmTaskMsgQue, MSG_SOCKTASK_OPEN, 0, 0);
            }
            break;
        case M_OPENERR:
            #if DEBUG_UARTNo_SOCKET <= 3
            PrintFromUART(DEBUG_UARTNo_SOCKET, "M_OPENERR!\n");
            #endif
            if ((s_state == S_OPENING || s_state == S_OPENED) && so == c_sock) {
                s_state = S_CLOSING;
            }
            break;
        case M_CLOSED:
            #if DEBUG_UARTNo_SOCKET <= 3
            PrintFromUART(DEBUG_UARTNo_SOCKET, "M_CLOSED!\n");
            #endif
            if ((s_state == S_OPENED || s_state == S_OPENING) && so == c_sock) {
                #if DEBUG_UARTNo_SOCKET <= 3
                PrintFromUART(DEBUG_UARTNo_SOCKET, "<closing socket...>\n");
                #endif
                s_state = S_CLOSING;
            }
            break;
        case M_RXDATA:
            #if DEBUG_UARTNo_SOCKET <= 3
            PrintFromUART(DEBUG_UARTNo_SOCKET, "M_RXDATA!\n");
            PrintFromUART(DEBUG_UARTNo_SOCKET, "<receive data from socket>\n");
            FormatPrintDataBlock(FORMAT_HEX, DEBUG_UARTNo_SOCKET, (INT8U *)pkt->m_data, pkt->m_len);
            #endif

            /* handle receive data */
            InformGPRSRecv(CHA_TCP, (INT8U *)pkt->m_data, pkt->m_len);
            break;
        case M_TXDATA:
            #if DEBUG_UARTNo_SOCKET <= 3
            PrintFromUART(DEBUG_UARTNo_SOCKET, "M_TXDATA!\n");
            PrintFromUART(DEBUG_UARTNo_SOCKET, "<send data from socket success>\n");
            #endif
            break;
        default:
            break;
    }
    return 0;
}

static void CloseSocket(void)
{
    int result;

    s_state = S_CLOSED;
    sendlen = 0;
    if (c_sock != NULL) {
        result = m_close(c_sock);
        c_sock = NULL;

        #if DEBUG_UARTNo_SOCKET <= 3
        if (result == 0)
            PrintFromUART(DEBUG_UARTNo_SOCKET, "<socket is closed>\n");
        else
            PrintFromUART(DEBUG_UARTNo_SOCKET, "<close socket error>\n");
        #endif
    }

    OSQPost(GsmTaskMsgQue, MSG_SOCKTASK_CLOSE, 0, 0);
}

static void ConnectSocket(void)
{
    int      temp;
    unsigned snbits;
    ip_addr  ipaddr;
    unsigned int ipport;
    struct   sockaddr_in sa;

    if (parse_ipad(&ipaddr, &snbits, host_ipaddr) != NULL) {
        #if DEBUG_UARTNo_SOCKET <= 3
        PrintFromUART(DEBUG_UARTNo_SOCKET, "<sorry, IP address error>\n");
        #endif
        return;
    }
    ipport = AsciiToDec((INT8U *)host_ipport, strlen(host_ipport));


/*  sa.sin_addr.s_addr = activehost;                         host ip address */
/*  sa.sin_addr.s_addr = htonl(0xDAF62F05);                  host ip address (218.246.47.5) */
/*  sa.sin_port        = htons(9000);                        host port */
    sa.sin_addr.s_addr = ipaddr;                            /* host ip address */
    sa.sin_port        = htons(ipport);                     /* host port */
    sa.sin_family      = AF_INET;
    if ((c_sock = m_socket()) == NULL) {
        dtrap("socktask 1\n");
        return;
    }
    #if DEBUG_UARTNo_SOCKET <= 3
    PrintFromUART(DEBUG_UARTNo_SOCKET, "<socket is created>\n");
    #endif

    s_state = S_OPENING;                                    /* s_state = S_OPENING */
    temp = 0;
    m_ioctl(c_sock, SO_LINGER, &temp);                      /* set socket linger */
    m_ioctl(c_sock, SO_NBIO, NULL);                         /* set socket nonblock mode */
    m_connect(c_sock, &sa, CallbackProc);                   /* now connect socket !!! */
}

static void InitSockTask(void)
{
    sendlen     = 0;
    c_sock      = NULL;
    ct_sendwait = 0;

    #if DEBUG_UARTNo_SOCKET <= 3
    InitUART(DEBUG_UARTNo_SOCKET, DEBUG_UART_BAUD);
    #endif

    wdgid = ApplyWatchDogID();
}

static void SockTask(void *pdata)
{
    PACKET pkt;

    pdata = pdata;

    InitSockTask();
    for (;;) {
        ResetWatchDog(wdgid);                                   /* clear watch dog */
        if (OSQPend(MsgQue, 1, &CurMsg) == OS_NO_ERR) {
            if (CurMsg.MsgID == MSG_SOCKTASK_REQUESTOPEN) {
                ConnectSocket();
            } else if (CurMsg.MsgID == MSG_SOCKTASK_REQUESTCLOSE) {
                CloseSocket();
            }
        }

        switch(s_state)
        {
            case S_OPENED:
                if (lilfreeq.q_len < 5 || bigfreeq.q_len < 3) {
                    ct_sendwait++;
                    if (ct_sendwait == MAX_WAIT_SEND)
                        OSQPost(GsmTaskMsgQue, MSG_SOCKTASK_SENDFLOW, 0, 0);
                    else if (ct_sendwait > MAX_WAIT_ERR)
                        dtrap("TCPIP queue buffer is wrong!\n");
                    OSQPost(GsmTaskMsgQue, MSG_SOCKTASK_SENDFLOW, 0, 0);//add 2004.04.07
                } else if (sendlen > 0) {
                    ct_sendwait = 0;
                    pkt = tcp_pktalloc(sendlen);
                    if (pkt == NULL) {
                        #if DEBUG_UARTNo_SOCKET <= 3
                        PrintFromUART(DEBUG_UARTNo_SOCKET, "<can not alloc packet for socket>\n");
                        #endif

                        CloseSocket();
                        break;
                    }
                    memcpy(pkt->m_data, sendmem, sendlen);
                    pkt->m_len = sendlen;
                    if (tcp_send(c_sock, pkt) == 0) {
                        #if DEBUG_UARTNo_SOCKET <= 3
                        PrintFromUART(DEBUG_UARTNo_SOCKET, "<sending data from socket...>\n");
                        #endif
                        sendlen = 0;

                        /* send message to gsmtask */
                        OSQPost(GsmTaskMsgQue, MSG_SOCKTASK_FREE, 0, 0);
                    } else {
                        #if DEBUG_UARTNo_SOCKET <= 3
                        PrintFromUART(DEBUG_UARTNo_SOCKET, "<send data from socket error, now free packet>\n");
                        #endif
                        tcp_pktfree(pkt);               /* free packet */
                    }
                }
                break;
            case S_CLOSING:
                CloseSocket();
                break;
            default:
                break;
        }
    }
}

BOOLEAN CanSendFromSocket(void)
{
    if (s_state != S_OPENED || sendlen > 0) return FALSE;
    else return TRUE;
}

BOOLEAN SendFromSocket(INT8U *data, INT16U len)
{
    if (CanSendFromSocket() && len <= sizeof(sendmem)) {
        memcpy(sendmem, data, len);
        sendlen = len;
        OSQPost(MsgQue, MSG_SOCKTASK_TSK, 0, 0);
        return TRUE;
    } else {
        return FALSE;
    }
}

BOOLEAN RequestCloseSocket(void)
{
    if (s_state == S_CLOSED) return FALSE;
    else {
        OSQPost(MsgQue, MSG_SOCKTASK_REQUESTCLOSE, 0, 0);
        return TRUE;
    }
}

BOOLEAN RequestOpenSocket(char *ipaddr, char *ipport)
{
    if (s_state != S_CLOSED) return FALSE;
    else {
        memcpy(host_ipaddr, ipaddr, sizeof(host_ipaddr));
        memcpy(host_ipport, ipport, sizeof(host_ipport));
        OSQPost(MsgQue, MSG_SOCKTASK_REQUESTOPEN, 0, 0);
        return TRUE;
    }
}

BOOLEAN SocketIsClosed(void)
{
    if (s_state == S_CLOSED) return TRUE;
    else return FALSE;
}

BOOLEAN SocketIsOpened(void)
{
    if (s_state == S_OPENED) return TRUE;
    else return FALSE;
}

void CreateSockTask(void)
{
    MsgQue = OSQCreate(MsgBuf, sizeof(MsgBuf)/sizeof(MsgBuf[0]));
    OSTaskCreate(SockTask, (void *)0, &SockTaskStack[STACK_SOCKTASK], PRIO_SOCKTASK);
}