at_sm.c

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

/****************************************************************
**                                                              *
**  FILE         :  AT_SM.C                                     *
**  COPYRIGHT    :  (c) 2001 .Xiamen Yaxon NetWork CO.LTD       *
**                                                              *
**                                                              *
**  By : CCH 2002.1.15                                          *
****************************************************************/
#include "includes.h"
#include "bsp.h"
#include "tools.h"
#include "message.h"
#include "errcode.h"
#include "timetask.h"
#include "errtask.h"
#include "gsmtask.h"
#include "pdumode.h"
#include "at_cmd.h"
#include "at_trans.h"
#include "at_core.h"
#include "at_sm.h"
#include "zprint.h"


/*
********************************************************************************
*                  DEFINE CONFIG PARAMETERS
********************************************************************************
*/
#define SIZE_MEMBUF                 512
#define DEF_SUSPEND                 5                               /* unit: SECOND */
#define ERR_SUSPEND                 20                              /* unit: SECOND */

#define PERIOD_WAIT                 MILTICK, 5                      /* define wait period */


/*
********************************************************************************
*                  DEFINE STATUS
********************************************************************************
*/
#define SM_FREE                     0
#define SM_SUSPEND                  1
#define SM_SENDHEAD                 2
#define SM_WAIT                     3
#define SM_SENDPDU                  4
#define SM_MASK                     0x0f
#define SM_READY                    0x40


/*
********************************************************************************
*                  DEFINE MODULE VARIANT
********************************************************************************
*/
static INT8U   status;
static INT8U   ct_clog, time_suspend;
static INT16U  memlen, headlen;
static INT8U   membuf[SIZE_MEMBUF];
static INT8U   tmpbuf[SIZE_MEMBUF];
static void   *infdata;
static void (*infproc)(INT8U result, void *pdata);
static TMR_TSK *waittmr;


static void FreeCurCmd(INT8U result)
{
    if ((status & SM_MASK) == SM_FREE || (status & SM_MASK) == SM_SUSPEND) return;
    
    OSQPost(GsmTaskMsgQue, MSG_ATSM_RESULT, result, 0);         /* send message */
    status &= ~SM_MASK;
    status |=  SM_SUSPEND;
    status &= ~SM_READY;
    if (time_suspend == 0 || time_suspend > 60) SetDefSMSuspendTime();
    StartTmr(waittmr, SECOND, time_suspend);
    if (infproc != 0) infproc(result, infdata);
}

static void InformSendHead(INT8U result, const ATCMDACK_STRUCT *ATCmdAck)
{
    ATCmdAck = ATCmdAck;
    if (result == AT_SUCCESS) {
        status &= ~SM_MASK;
        status |=  SM_WAIT;
        StartTmr(waittmr, PERIOD_WAIT);
    } else {
        FreeCurCmd(_FAILURE);
    }
}

static void InformSendPDU(INT8U result, const ATCMDACK_STRUCT *ATCmdAck)
{
    ATCmdAck = ATCmdAck;
    if (result == AT_SUCCESS) {
        NotifySendSMSuccess();
        FreeCurCmd(_SUCCESS);
    } else {
        NotifySendSMFailure();
        FreeCurCmd(_FAILURE);
    }
}

static void WaitTmrProc(void)
{
    StopTmr(waittmr);                                       /* stop timer */
    if ((status & SM_MASK) == SM_WAIT) {
        status &= ~SM_MASK;
        status |=  SM_SENDPDU;
        status |=  SM_READY;
        OSQPost(GsmTaskMsgQue, MSG_ATSM_TSK, 0, 0);         /* send message */
    } else if ((status & SM_MASK) == SM_SUSPEND) {
        status &= ~SM_MASK;
        status &= ~SM_READY;
        OSQPost(GsmTaskMsgQue, MSG_ATSM_FREE, 0, 0);        /* send message */
    }
}

static void DiagnoseProc(void)
{
    if ((status & SM_MASK) > SM_SENDPDU) ErrExit(ERR_ATSM_STATUS);
    if ((status & SM_MASK) == SM_WAIT || (status & SM_MASK) == SM_SUSPEND) {
        if (GetTmrSwitch(waittmr) != ON) ErrExit(ERR_ATSM_TMR);
    }
}

void InitAT_SM(void)
{
    status  = 0;                                            /* initialize status */
    ct_clog = 0;
    waittmr = CreateTimer(WaitTmrProc, 0);                  /* create wait timer */
	SetDefSMSuspendTime();
    InstallDiagProc(DiagnoseProc);                          /* install diagnose function */
}

void ResetAT_SM(void)
{
    FreeCurCmd(_FAILURE);
    status  = 0;
    ct_clog = 0;
    SetDefSMSuspendTime();
    StopTmr(waittmr);
}

BOOLEAN CanSendSM(void)
{
    if ((status & SM_MASK) == SM_FREE && ct_clog == 0 && !SMIsProhibited()) return TRUE;
    else return FALSE;
}

BOOLEAN IsSendingSM(void)
{
    switch (status & SM_MASK)
    {
        case SM_FREE:
        case SM_SUSPEND:
            return FALSE;
        case SM_SENDHEAD:
            if (status & SM_READY) return FALSE;
            else return TRUE;
        case SM_WAIT:
        case SM_SENDPDU:
            return TRUE;
        default:
            return FALSE;
    }
}

void ClogSM(void)
{
    if (ct_clog != 0xff) ct_clog++;
}

void UnclogSM(void)
{
    if (ct_clog > 0) ct_clog--;
    if (ct_clog == 0) {
        OSQPost(GsmTaskMsgQue, MSG_ATSM_TSK, 0, 0);
        OSQPost(GsmTaskMsgQue, MSG_ATSM_UNCLOGSM, 0, 0);
    }
}

BOOLEAN IsClogSM(void)
{
    if (ct_clog > 0) return TRUE;
    else return FALSE;
}

BOOLEAN SendSM_DCS(INT8U dcs, INT8U *telptr, INT8U tellen, INT8U *dataptr, INT8U datalen, void (*fp)(INT8U result, void *pdata), void *pdata)
{
    if (!SIMCardInserted() || !NetworkRegisted()) return FALSE;
    if (!CanSendSM()) return FALSE;
    if ((memlen = AssemblePDUData(dcs, telptr, tellen, dataptr, datalen, membuf, tmpbuf)) == 0) return FALSE;
    headlen = AT_CMGS(tmpbuf, (memlen - 2)/2);
    
    status &= ~SM_MASK;
    status |=  SM_SENDHEAD;
    status |=  SM_READY;
    infproc =  fp;
    infdata =  pdata;
    OSQPost(GsmTaskMsgQue, MSG_ATSM_TSK, 0, 0);             /* send message */
    return TRUE;
}

void SetErrSMSuspendTime(void)
{
    time_suspend = ERR_SUSPEND;
}

void SetDefSMSuspendTime(void)
{
    time_suspend = DEF_SUSPEND;
}

void AbortCurSM(void)
{
    switch (status & SM_MASK)
    {
        case SM_FREE:
        case SM_SUSPEND:
            break;
        case SM_WAIT:
            EscapeATCmd();
            FreeCurCmd(_FAILURE);
            break;
        case SM_SENDHEAD:
            if ((status & SM_READY) == 0) EscapeATCmd();
            break;
        case SM_SENDPDU:
            if ((status & SM_READY) == 0) EscapeATCmd();
            else {
                EscapeATCmd();
                FreeCurCmd(_FAILURE);
            }
            break;
        default:
            ;
    }
}

void AT_SMEntry(void)
{
    switch (status & SM_MASK)
    {
        case SM_FREE:
        case SM_SUSPEND:
        case SM_WAIT:
            break;
        case SM_SENDHEAD:
            if (CanSendATCmd(DLC_SM) && (status & SM_READY) == SM_READY && ct_clog == 0) {
                status &= ~SM_READY;
                SendATCmd(DLC_SM, &AT_CMGS_PARA, tmpbuf, headlen, InformSendHead);
                OSQPost(GsmTaskMsgQue, MSG_ATSM_SENDSHORTMSG, 0, 0);
            }
            break;
        case SM_SENDPDU:
            if (CanSendATCmd(DLC_SM) && (status & SM_READY) == SM_READY) {
                status &= ~SM_READY;
                SendATCmd(DLC_SM, &AT_CMGS_PDU_PARA, membuf, memlen, InformSendPDU);
            }
            break;
        default:
            ErrExit(ERR_ATSM_STATUS);
    }
}