manser.c

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

/****************************************************************
**                                                              *
**  FILE         :  ManSer.C                                    *
**  COPYRIGHT    :  (c) 2001 .Xiamen Yaxon NetWork CO.LTD       *
**                                                              *
**                                                              *
**  By : CCH 2002.1.15                                          *
****************************************************************/
#include "includes.h"
#include "bsp.h"
#include "tools.h"
#include "hardware.h"
#include "public.h"
#include "stream.h"
#include "sysframe.h"
#include "stream.h"
#include "itemmenu.h"
#include "systask.h"
#include "portdrv.h"
#include "at_set.h"
#include "rx_frame.h"
#include "sm_list.h"
#include "gpsdrv.h"
#include "gprsdrv.h"
#include "odometer.h"
#include "monitor.h"
#include "alarmer.h"
#include "callrht.h"
#include "autodial.h"
#include "position.h"
#include "manser.h"
#include "GpsRecer.h"
#include "Printer.h"
#include "PhoneDrv.h"
#if EN_ODOMETER1 > 0
#include "OdoMeter1.h"
#endif
#if EN_LCD > 0
#include "lcddrv.h"
#include "LCDList.h"
#endif

#if EN_HANDSET > 0
#if EN_HSTSMON > 0
#include "HstSmon.h"
#endif
#endif

#if EN_BLACKBOX > 0 //qzc
#include "blkSave.h"
#include "blkquery.h"
#endif


static STREAM rstrm, *wstrm;
static INT16U hdlframelen;
static INT16U channeltype;
static SYSFRAME_STRUCT *hdlframe;
#if EN_HSTSMON > 0
static INT8U  SumonBuf[100];//add by qzc
#endif
/*
********************************************************************************
* Handler:  MSG_0x1001
********************************************************************************
*/
static void HdlMsg_0x1001(void)
{
    INT8U acktype;

    EgCode.egcode = GetEgcode_SYSFrame(hdlframe);
    VirStorePubPara(EGCODE_);                                       /* set egcode */
    ChangeMonitorEgcode();

    SmsTel.len = DecodeTel(SmsTel.tel, GetStrmPtr(&rstrm), sizeof(SmsTel.tel));
    VirStorePubPara(SMSTEL_);                                       /* set SMS tel */
    StoreMyTel_SYSFrame(hdlframe);                                  /* set my tel */

    if (SetCSCA(0, SmsTel.tel, SmsTel.len)) {
        acktype = _SYSFRAME_ACK;
    } else {
        acktype = _SYSFRAME_NAK;
    }

    ASMSYSFrameHead_MODE1(wstrm, hdlframe, 0x1041);
    WriteBYTE_Strm(wstrm, acktype);
    SendSYSFrame_MODE1(wstrm, hdlframe, SM_ATTR_COMMON | channeltype);
}

/*
********************************************************************************
* Handler:  MSG_0x1002
********************************************************************************
*/
static void HdlMsg_0x1002(void)
{
    AlarmTel.len = DecodeTel(AlarmTel.tel, GetStrmPtr(&rstrm), sizeof(AlarmTel.tel));
    VirStorePubPara(ALARMTEL_);                                     /* set alarm tel */
    ReEnterAlarm();                                                 /* reenter alarm status */
    MovStrmPtr(&rstrm, sizeof(AlarmTel.tel));

    TaxTel.tellen = DecodeTel(TaxTel.tel, GetStrmPtr(&rstrm), sizeof(TaxTel.tel));
    VirStorePubPara(TAXTEL_);                                       /* set tax tel */
    MovStrmPtr(&rstrm, sizeof(TaxTel.tel));

    AttemperTel.len = DecodeTel(AttemperTel.tel, GetStrmPtr(&rstrm), sizeof(AttemperTel.tel));
    StorePubPara(ATTEMPERTEL_);                                     /* set attemper tel */

    ASMSYSFrameHead_MODE1(wstrm, hdlframe, 0x1042);
    WriteBYTE_Strm(wstrm, _SYSFRAME_ACK);
    SendSYSFrame_MODE1(wstrm, hdlframe, SM_ATTR_SUCCESS | channeltype);

    AddAutoMonitor();
}

/*
********************************************************************************
* Handler:  MSG_0x1003
********************************************************************************
*/
static void HdlMsg_0x1003(void)
{
    INT8U num, i;

    num = ReadBYTE_Strm(&rstrm);
    if (num == 0x7f) num = 0;

    ASMSYSFrameHead_MODE1(wstrm, hdlframe, 0x1043);
    if (num > MAX_LISTENTEL) {
        WriteBYTE_Strm(wstrm, _SYSFRAME_NAK);
    } else {
        ListenTel.num = num;
        for (i = 0; i < num; i++) {
            ListenTel.tel[i].tellen = DecodeTel(ListenTel.tel[i].tel, GetStrmPtr(&rstrm), sizeof(ListenTel.tel[i].tel));
            MovStrmPtr(&rstrm, sizeof(ListenTel.tel[i].tel));
        }
        StorePubPara(LISTENTEL_);                   /* store listen tel */
        WriteBYTE_Strm(wstrm, _SYSFRAME_ACK);
    }
    SendSYSFrame_MODE1(wstrm, hdlframe, SM_ATTR_SUCCESS | channeltype);
}

/* chen qi fu */
/*
********************************************************************************
* Handler:  MSG_0x1007
********************************************************************************
*/
static void HdlMsg_0x1007(void)
{
   INT8U acktype;

   ConvertData(hdlframe->data, hdlframelen, 0, 0x7f);
   if(SetPosition(hdlframe->data)) acktype=_SYSFRAME_ACK;
   else acktype=_SYSFRAME_NAK;
   ASMSYSFrameHead_MODE1(wstrm, hdlframe, 0x1047);
   WriteBYTE_Strm(wstrm, acktype);
   SendSYSFrame_MODE1(wstrm, hdlframe, SM_ATTR_SUCCESS | channeltype);
}


/*
********************************************************************************
* Handler:  MSG_0x1008
********************************************************************************
*/
static void HdlMsg_0x1008(void)
{
    ASMSYSFrameHead_MODE1(wstrm, hdlframe, 0x1048);
    if (SetCallRHT(GetStrmPtr(&rstrm)))
        WriteBYTE_Strm(wstrm, _SYSFRAME_ACK);
    else
        WriteBYTE_Strm(wstrm, _SYSFRAME_NAK);
    SendSYSFrame_MODE1(wstrm, hdlframe, SM_ATTR_SUCCESS | channeltype);
}


/*
********************************************************************************
* Handler:  MSG_0x1009
********************************************************************************
*/
static void HdlMsg_0x1009(void)
{
    ConfigAlarmer(ReadHWORD_Strm(&rstrm));

    ASMSYSFrameHead_MODE1(wstrm, hdlframe, 0x1049);
    WriteBYTE_Strm(wstrm, _SYSFRAME_ACK);
    SendSYSFrame_MODE1(wstrm, hdlframe, SM_ATTR_SUCCESS | channeltype);
}

/*
********************************************************************************
* Handler:  MSG_0x100e
********************************************************************************
*/
static void HdlMsg_0x100e(void)
{

}

/*
********************************************************************************
* Handler:  MSG_0x1012    //yyy
********************************************************************************
*/
static void HdlMsg_0x1012(void)
{
#if EN_BLACKBOX > 0
    INT8U   TempM,TempS;

    TempM = ReadBYTE_Strm(&rstrm);
    TempS = ReadBYTE_Strm(&rstrm);

    if (TempM == 0x7f) TempM = 0;
    if (TempS == 0x7f) TempS = 0;

    if ((TempM == 0) && (TempS < 3)) {
       ASMSYSFrameHead_MODE1(wstrm, hdlframe, 0x1052);
       WriteBYTE_Strm(wstrm, _SYSFRAME_NAK);
       SendSYSFrame_MODE1(wstrm, hdlframe, SM_ATTR_SUCCESS | channeltype);
    } else {
       BBoxTCB.IntervalM = TempM;
       BBoxTCB.IntervalS = TempS;
       StorePubPara(BBOXTCB_);
       //StartStore();  //close by qzc
       ASMSYSFrameHead_MODE1(wstrm, hdlframe, 0x1052);
       WriteBYTE_Strm(wstrm, _SYSFRAME_ACK);
       SendSYSFrame_MODE1(wstrm, hdlframe, SM_ATTR_SUCCESS | channeltype);
    }
#endif
}

/*	//chenqifu add 0917
********************************************************************************
* Handler:  MSG_0x1015
********************************************************************************
*/
static void HdlMsg_0x1015(void)
{
   INT8U acktype;

   ConvertData(hdlframe->data, hdlframelen, 0, 0x7f);
   if(SetRelation(hdlframe->data)) acktype=_SYSFRAME_ACK;
   else acktype=_SYSFRAME_NAK;
   ASMSYSFrameHead_MODE1(wstrm, hdlframe, 0x1055);
   WriteBYTE_Strm(wstrm, acktype);
   SendSYSFrame_MODE1(wstrm, hdlframe, SM_ATTR_SUCCESS | channeltype);
}

/*
********************************************************************************
* Handler:  MSG_0x103b
********************************************************************************
*/
static void HdlMsg_0x103b(void)
{
    INT8U  paranum, paratype, paralen;
    INT8U  temp_8, i, tag, statetype;

    paranum = ReadBYTE_Strm(&rstrm);
    if (paranum == 0x7f) paranum = 0;
    for (; paranum > 0; paranum--) {
        paratype = ReadBYTE_Strm(&rstrm);
        paralen  = ReadBYTE_Strm(&rstrm);
        switch (paratype)
        {
            case 0x01:
                temp_8 = ReadBYTE_Strm(&rstrm);
                if (temp_8 == 0x7f) temp_8 = 0;
                OnlineMode.gprsonline = temp_8;

                if (temp_8 == 0x00) {
                    ActivateGPRS(ACTIVATE_UDP);                     /* activate gprs */
                } else if (temp_8 == 0x01) {
                    ActivateGPRS(ACTIVATE_TCP);                     /* activate gprs */
                } else {
                    DelayDeactivateGPRS();
                }
                VirStorePubPara(ONLINEMODE_);
                break;
            case 0x02:
                AutoMonitorPara.ctlflag = ReadBYTE_Strm(&rstrm);
                i = ReadBYTE_Strm(&rstrm);
                if (i == 0x7f) i = 0;
                for (; i > 0; i--) {
                    statetype = ReadBYTE_Strm(&rstrm);
                    if((statetype==0x03)||(statetype==0x04)) AutoMonitorPara.ctlflag |=0x80;//以空重车状态为主
                    switch (statetype)
                    {
                        case 0x01:
                            tag = 0;
                            break;
                        case 0x02:
                            tag = 1;
                            break;
                        case 0x03: //空车
                        	 tag = 2;
                        	 break;
                        case 0x04: //重车
                        	 tag = 3;
                        	 break;
                        default:
                            tag = MAX_AUTOMONITORPARA - 1;
                            break;
                    }

                    AutoMonitorPara.para[tag].servicetype   = ReadBYTE_Strm(&rstrm);
                    AutoMonitorPara.para[tag].monitortime   = ReadHWORD_Strm(&rstrm);
                    AutoMonitorPara.para[tag].monitorperiod = ReadHWORD_Strm(&rstrm);
                    AutoMonitorPara.para[tag].fixedspace    = ReadHWORD_Strm(&rstrm);
                    ConvertData((INT8U *)&AutoMonitorPara.para[tag].monitortime,   sizeof(AutoMonitorPara.para[tag].monitortime),   0x0, 0x7f);
                    ConvertData((INT8U *)&AutoMonitorPara.para[tag].monitorperiod, sizeof(AutoMonitorPara.para[tag].monitorperiod), 0x0, 0x7f);
                    ConvertData((INT8U *)&AutoMonitorPara.para[tag].fixedspace,    sizeof(AutoMonitorPara.para[tag].fixedspace),    0x0, 0x7f);
                }
                VirStorePubPara(AUTOMONITORPARA_);
                AddAutoMonitor();
                break;
            case 0x03:
                OnlinePrompt.prompttype = ReadBYTE_Strm(&rstrm);
                VirStorePubPara(ONLINEPROMPT_);
                break;
            case 0x04:
                GprsBackup.backuptype = ReadHWORD_Strm(&rstrm);
                VirStorePubPara(GPRSBACKUP_);
                break;
            default:
                break;
        }
    }
    StoreAllPubPara();

    ASMSYSFrameHead_MODE1(wstrm, hdlframe, 0x107b);
    WriteBYTE_Strm(wstrm, _SYSFRAME_ACK);
    SendSYSFrame_MODE1(wstrm, hdlframe, SM_ATTR_SUCCESS | channeltype);
}

/*
********************************************************************************
* Handler:  MSG_0x103c
********************************************************************************
*/
static void HdlMsg_0x103c(void)
{
    INT8U   flag, num, pos, tag;
    BOOLEAN isvalid;

    EgCode.egcode = GetEgcode_SYSFrame(hdlframe);
    VirStorePubPara(EGCODE_);                                       /* set egcode */
    ChangeMonitorEgcode();

    ConvertData(hdlframe->data, hdlframelen, 0x0, 0x7f);            /* 0x7f -----> 0x00 */

    isvalid = TRUE;
    flag    = ReadBYTE_Strm(&rstrm);
    if ((flag & 0x01) == 0) {
        for (tag = 0; tag < MAX_IPNUM; tag++)
            GprsIP.ippara[tag].isvalid = FALSE;
    }

    tag = 0;
    num = ReadBYTE_Strm(&rstrm);
    for (; num > 0; num--) {
        tag = ReadBYTE_Strm(&rstrm);
        if (tag >= MAX_IPNUM) {
            isvalid = FALSE;
            break;
        }
        pos = DecodeTel((INT8U *)GprsIP.ippara[tag].apn,      GetStrmPtr(&rstrm), 20); /* for APN field */
        GprsIP.ippara[tag].apn[pos]      = 0;
        MovStrmPtr(&rstrm, 20);
        pos = DecodeTel((INT8U *)GprsIP.ippara[tag].tcp_ip,   GetStrmPtr(&rstrm), 15); /* for TCP_IP field */
        GprsIP.ippara[tag].tcp_ip[pos]   = 0;
        MovStrmPtr(&rstrm, 15);
        pos = DecodeTel((INT8U *)GprsIP.ippara[tag].tcp_port, GetStrmPtr(&rstrm), 5);  /* for TCP_PORT field */
        GprsIP.ippara[tag].tcp_port[pos] = 0;
        MovStrmPtr(&rstrm, 5);
        pos = DecodeTel((INT8U *)GprsIP.ippara[tag].ivudp_ip,   GetStrmPtr(&rstrm), 15); /* for IVUDP_IP field */
        GprsIP.ippara[tag].ivudp_ip[pos]   = 0;
        MovStrmPtr(&rstrm, 15);
        pos = DecodeTel((INT8U *)GprsIP.ippara[tag].ivudp_port, GetStrmPtr(&rstrm), 5);  /* for IVUDP_PORT field */
        GprsIP.ippara[tag].ivudp_port[pos] = 0;
        MovStrmPtr(&rstrm, 5);
        pos = DecodeTel((INT8U *)GprsIP.ippara[tag].udp_ip,   GetStrmPtr(&rstrm), 15); /* for UDP_IP field */
        GprsIP.ippara[tag].udp_ip[pos]   = 0;
        MovStrmPtr(&rstrm, 15);
        pos = DecodeTel((INT8U *)GprsIP.ippara[tag].udp_port, GetStrmPtr(&rstrm), 5);  /* for UDP_PORT field */
        GprsIP.ippara[tag].udp_port[pos] = 0;
        MovStrmPtr(&rstrm, 5);
        GprsIP.ippara[tag].isvalid = TRUE;
    }

    ASMSYSFrameHead_MODE1(wstrm, hdlframe, 0x107c);
    WriteBYTE_Strm(wstrm, tag);
    if (isvalid) {
        WriteBYTE_Strm(wstrm, _SYSFRAME_ACK);
        VirStorePubPara(GPRSIP_);
        StoreMyTel_SYSFrame(hdlframe);                                  /* set my tel */
        SuspendGPRS();
    } else {
        WriteBYTE_Strm(wstrm, _SYSFRAME_NAK);
        InitAllPubPara();
    }

    SendSYSFrame_MODE1(wstrm, hdlframe, SM_ATTR_SUCCESS | channeltype);
}

/*
********************************************************************************
* Handler:  MSG_0x1032
********************************************************************************
*/
static void HdlMsg_0x1032(void)
{
    INT8U temp_8, ack;

    temp_8 = ReadBYTE_Strm(&rstrm);
    if (temp_8 == 0x7f) temp_8 = 0x0;
    if (OnlineMode.gprsonline != 0x00 && OnlineMode.gprsonline != 0x01) {
        if (temp_8 == 0x00) {
            ActivateGPRS(ACTIVATE_UDP);
        } else if (temp_8 == 0x01) {
            ActivateGPRS(ACTIVATE_TCP);
        } else if (temp_8 == 0x02) {
            DelayDeactivateGPRS();                   /* deactivate gprs */
        }
        ack = _SYSFRAME_ACK;
    } else {
        ack = _SYSFRAME_NAK;
    }

    ASMSYSFrameHead_MODE1(wstrm, hdlframe, 0x1072);
    WriteBYTE_Strm(wstrm, temp_8);
    WriteBYTE_Strm(wstrm, ack);
    SendSYSFrame_MODE1(wstrm, hdlframe, SM_ATTR_SUCCESS | channeltype);