monitor.c

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

/****************************************************************
**                                                              *
**  FILE         :  Monitor.C                                   *
**  COPYRIGHT    :  (c) 2001 .Xiamen Yaxon NetWork CO.LTD       *
**                                                              *
**                                                              *
**  By : CCH 2002.1.15                                          *
****************************************************************/
#include "includes.h"
#include "structs.h"
#include "message.h"
#include "errtask.h"
#include "public.h"
#include "tools.h"
#include "systime.h"
#include "timetask.h"
#include "gpsdrv.h"
#include "gprsdrv.h"
#include "gpsrecer.h"
#include "sm_list.h"
#include "at_core.h"
#include "sysframe.h"
#include "odometer.h"
#include "alarmer.h"
#include "gsmtask.h"
#include "almtask.h"
#include "sensor.h"
#include "monitor.h"

#if EN_NOSIGNALRESEND > 0
#include "r_send.h"
#endif


/*
********************************************************************************
*                  DEFINE CONFIG PARAMETERS
********************************************************************************
*/
#define SIZE_GPSBUF                     110
#define SIZE_SENDBUF					160
#define MAX_MONITOR                     4

#if EN_CODE6 > 0
#define MAX_COMGPS1                     11
#define MAX_COMGPS2                     7
#else
#define MAX_COMGPS1                     14
#define MAX_COMGPS2                     9
#endif

#define PERIOD_DEFQUERY                 30                  /* PERIOD_DEFQUERY = 30 minute */
#define PERIOD_QUERY                    MINUTE,  1
#define PERIOD_STARTDELAY1              MILTICK, 2
#define PERIOD_STARTDELAY2              SECOND,  2


/*
********************************************************************************
*                  DEFINE _ALLOW
********************************************************************************
*/
#define _ALLOW                          0xAA


/*
********************************************************************************
*                  DEFINE MONITOR PARAMETERS STRUCTURE
********************************************************************************
*/
typedef struct {
    INT8U           channeltype;
    BOOLEAN         gpscansleep;
    INT16U          egcode;
    INT8U           servicetype;
    INT16U          monitortime;
    INT16U          periodtime;
    INT16U          fixedspace;
    INT8U           mttellen;
    INT8U           mttel[SYS_TELLEN];
    INT16U          querytime;
    INT8U           meterid;
    TMR_TSK        *monitortmr;
    TMR_TSK        *periodtmr;
} MONITOR_STRUCT;


/*
********************************************************************************
*                  DEFINE GPS BUFFER STRUCTURE
********************************************************************************
*/
typedef struct {
    INT8U           gpstype;
    INT8U           numgps;
    DATE_STRUCT     refdate;
    DATUM_STRUCT    predatum;
    INT8U           chksum;
    INT8U           gpslen;
    INT8U           buffer[SIZE_GPSBUF];
} GPSBUF_STRUCT;


/*
********************************************************************************
*                  DEFINE SEND BUFFER STRUCTURE
********************************************************************************
*/
typedef struct {
    BOOLEAN         isempty;
    INT8U           len;
    INT8U           buffer[SIZE_SENDBUF];
} SENDBUF_STRUCT;


/*
********************************************************************************
*                  DEFINE MODULE VARIANT
********************************************************************************
*/
static MONITOR_STRUCT monitor[MAX_MONITOR];
static GPSBUF_STRUCT  gpsbuf[MAX_MONITOR];
static SENDBUF_STRUCT sendbuf[MAX_MONITOR];

static TMR_TSK *querytmr;

static INT8U  nummonitor, sendchn;
static STREAM wstrm;
static MONITORENTRY_STRUCT tempmonitor;

static void ASMGpsData(INT8U id)
{
    INT8U gpstype;

    gpstype = gpsbuf[id].gpstype;
    WriteBYTE_Strm(&wstrm, gpstype | 0x40);
    WriteDATA_Strm(&wstrm, (INT8U *)&gpsbuf[id].refdate, sizeof(gpsbuf[id].refdate));

    if (gpstype == _COMGPS1 || gpstype == _COMGPS2) {
        WriteBYTE_Strm(&wstrm, gpsbuf[id].numgps);
        WriteHWORD_Strm(&wstrm, monitor[id].periodtime);
    }
    WriteDATA_Strm(&wstrm, gpsbuf[id].buffer, gpsbuf[id].gpslen);
    WriteBYTE_Strm(&wstrm, gpsbuf[id].chksum & 0x7f);
}

static void StartSendData(INT8U id)
{
    sendbuf[id].isempty = FALSE;
    sendbuf[id].len     = GetStrmLen(&wstrm);

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

static void ASM_0x0241(INT8U id)
{
    InitStrm(&wstrm, sendbuf[id].buffer, sizeof(sendbuf[id].buffer));
    ASMSYSFrameHead_MODE2(&wstrm, monitor[id].egcode, 0x0241);
    WriteBYTE_Strm(&wstrm, 0x40);                           /* position type ????? */
    WriteBYTE_Strm(&wstrm, 0x00);                           /* position sequence number */
    WriteHWORD_Strm(&wstrm, GetAlarmType());                 /* alarmtype */
    ASMGpsData(id);
    ConvertData(GetStrmStartPtr(&wstrm), GetStrmLen(&wstrm), 0x7f, 0x00);
    WriteBYTE_Strm(&wstrm, GetChkSum_7C(GetStrmStartPtr(&wstrm), GetStrmLen(&wstrm)));
    StartSendData(id);
}

static void ASM_0x0145(INT8U id)
{
    InitStrm(&wstrm, sendbuf[id].buffer, sizeof(sendbuf[id].buffer));
    ASMSYSFrameHead_MODE2(&wstrm, monitor[id].egcode, 0x0145);
    WriteHWORD_Strm(&wstrm, GetAlarmType());                 /* alarmtype */
    WriteBYTE_Strm(&wstrm, nummonitor);
    ASMGpsData(id);
    ConvertData(GetStrmStartPtr(&wstrm), GetStrmLen(&wstrm), 0x7f, 0x00);
    WriteBYTE_Strm(&wstrm, GetChkSum_7C(GetStrmStartPtr(&wstrm), GetStrmLen(&wstrm)));
    StartSendData(id);
}

static void ASM_0x0154(INT8U id)
{
    InitStrm(&wstrm, sendbuf[id].buffer, sizeof(sendbuf[id].buffer));
    ASMSYSFrameHead_MODE2(&wstrm, monitor[id].egcode, 0x0154);
    WriteHWORD_Strm(&wstrm, GetAlarmType());                 /* alarmtype */
    WriteBYTE_Strm(&wstrm, nummonitor);
    ASMGpsData(id);
    ConvertData(GetStrmStartPtr(&wstrm), GetStrmLen(&wstrm), 0x7f, 0x00);
    WriteBYTE_Strm(&wstrm, GetChkSum_7C(GetStrmStartPtr(&wstrm), GetStrmLen(&wstrm)));
    StartSendData(id);
}

static void ASM_0x0144(INT8U id, INT8U delreason)
{
    InitStrm(&wstrm, sendbuf[id].buffer, sizeof(sendbuf[id].buffer));
    ASMSYSFrameHead_MODE2(&wstrm, monitor[id].egcode, 0x0144);
    WriteBYTE_Strm(&wstrm, delreason);
    ConvertData(GetStrmStartPtr(&wstrm), GetStrmLen(&wstrm), 0x7f, 0x00);
    WriteBYTE_Strm(&wstrm, GetChkSum_7C(GetStrmStartPtr(&wstrm), GetStrmLen(&wstrm)));
    StartSendData(id);
}

static void PrepareGpsData(INT8U id)
{
    HWORD_UNION temp;
    BOOLEAN finished;
    INT8U  numgps, chksum, gpslen, gpstype;
    DATUM_STRUCT *predatum;
    INT8U *curptr;

    finished =  FALSE;
    numgps   =  gpsbuf[id].numgps;
    chksum   =  gpsbuf[id].chksum;
    gpslen   =  gpsbuf[id].gpslen;
    predatum = &gpsbuf[id].predatum;
    curptr   =  gpsbuf[id].buffer;
    gpstype  =  monitor[id].servicetype & 0x07;

    if (gpstype > _DIFGPS) ErrExit(ERR_MONITOR_GPSTYPE);
    if (gpstype == _DIFGPS) gpstype = _STDGPS;
    if (!GpsIsWorking()) {
        numgps  = 0;
        gpstype = _STDGPS;
    }

    if (numgps == 0) {
        GetSysTime_Date(&gpsbuf[id].refdate);               /* get systime date */
/*      if (GpsDataValid()) {                                get gpstime */
/*          gpslen  = GetGpsTime((TIME_STRUCT *)curptr);*/
/*          curptr += gpslen;*/
/*      } else {*/
            gpslen  = SysTimeToGpsTime((TIME_STRUCT *)curptr);
            curptr += gpslen;
/*      }*/
        temp = GetDatumData((DATUM_STRUCT *)curptr);
        memcpy(predatum, curptr, sizeof(DATUM_STRUCT));
        ConvertDatumData((DATUM_STRUCT *)curptr);
        gpslen += temp.bytes.low;
        chksum  = temp.bytes.high;
    } else {
        curptr += gpslen;
        if (gpstype == _COMGPS1) {
            temp = GetOffsetData1(predatum, (OFFSET1_STRUCT *)curptr);
        } else if (gpstype == _COMGPS2) {
            temp = GetDatumData((DATUM_STRUCT *)curptr);
            ConvertDatumData((DATUM_STRUCT *)curptr);
        } else {
            ErrExit(ERR_MONITOR_GPSTYPE);
        }
        gpslen += temp.bytes.low;
        chksum += temp.bytes.high;
    }
    if (temp.bytes.low > 0) numgps++;

    switch (gpstype)
    {
        case _COMGPS1:
            if (numgps >= MAX_COMGPS1 || temp.bytes.low == 0) finished = TRUE;
            break;
        case _COMGPS2:
            if (numgps >= MAX_COMGPS2) finished = TRUE;
            break;
        case _STDGPS:
            finished = TRUE;
            break;
        default:
            ErrExit(ERR_MONITOR_GPSTYPE);
    }

    gpsbuf[id].numgps  = numgps;
    gpsbuf[id].chksum  = chksum;
    gpsbuf[id].gpslen  = gpslen;
    gpsbuf[id].gpstype = gpstype;

    if (finished) {
        if (monitor[id].channeltype & MT_POSITION) ASM_0x0241(id);
        else if ((monitor[id].channeltype & (MT_MONITOR | MT_ALARM | MT_AUTOMONITOR)) == MT_AUTOMONITOR) ASM_0x0154(id);
        else ASM_0x0145(id);
        gpsbuf[id].numgps = 0;
    }
}

#pragma O0
static void StartNextPeriod(INT8U id)
{
    HWORD_UNION temp;
    INT8U  updatemode, meterattrib;
    INT16U tmrattrib, period, space;

    temp.hword = monitor[id].periodtime;
    if (temp.bytes.low & 0x40) tmrattrib = MINUTE;
    else tmrattrib = SECOND;
    period = temp.bytes.high * 60 + (temp.bytes.low & 0x3f);

    temp.hword = monitor[id].fixedspace;
    if (temp.bytes.high & 0x80) meterattrib = _KM;
    else meterattrib = _DM;
    temp.bytes.high &= 0x7f;
    space = temp.hword;

    updatemode = monitor[id].servicetype & 0x18;
    if (updatemode > _TIMING_OR_FIXEDSPACE) ErrExit(ERR_MONITOR_UPDATEMODE);

    if (updatemode == _FIXEDSPACE || updatemode == _TIMING_OR_FIXEDSPACE) {
        StartMeter(monitor[id].meterid, meterattrib, space);
    } else {
        StopMeter(monitor[id].meterid);
    }
    if (updatemode == _TIMING || updatemode == _TIMING_OR_FIXEDSPACE) {
        if (period == 0) ErrExit(ERR_MONITOR_PERIOD);
        StartTmr(monitor[id].periodtmr, tmrattrib, period);
    } else {
        StopTmr(monitor[id].periodtmr);
    }
}


static void Cancel(INT8U id, INT8U delreason)
{
    nummonitor--;
    if (monitor[id].channeltype & MT_ALARM) {
        OSQPost(AlmTaskMsgQue, MSG_ALARMER_CANCEL, 0, 0);
    }

    /* clear gps channel ????? */
    sendbuf[id].isempty     = TRUE;
    monitor[id].channeltype = MT_EMPTY;
    RemoveMeter(monitor[id].meterid);
    RemoveTmr(monitor[id].periodtmr);
    RemoveTmr(monitor[id].monitortmr);

    if (!monitor[id].gpscansleep) ReleaseGps();
    if (delreason != _DEL_COMMON) ASM_0x0144(id, delreason);

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

static void QueryTmrProc(void)
{
    INT8U i;

    StartTmr(querytmr, PERIOD_QUERY);
    for (i = 0; i < MAX_MONITOR; i++) {
        if (monitor[i].querytime > 0 && (monitor[i].channeltype & (MT_MONITOR | MT_ALARM))) {
            monitor[i].querytime--;
            if (monitor[i].querytime == 0) Cancel(i, _DEL_QUERY);
        }
    }
}

static void MonitorTmrProc(void)
{
    INT8U id;

    id = GetCurTmrIndex();
    StopTmr(monitor[id].monitortmr);
    Cancel(id, _DEL_OVERTIME);
}

static void PeriodTmrProc(void)
{
    INT8U id;

    id = GetCurTmrIndex();
    PrepareGpsData(id);
    StartNextPeriod(id);
}

static void MeterProc(INT8U tag)
{
    PrepareGpsData(tag);
    StartNextPeriod(tag);
}

static BOOLEAN CheckEntry_BASE(MONITORENTRY_STRUCT *entry)
{
    INT8U channeltype;

    channeltype = entry->channeltype;
    if ((channeltype & 0x0F) == 0 || (channeltype & MT_EMPTY)) return FALSE;
/*  if (channeltype != MT_POSITION && channeltype != MT_ALARM && channeltype != MT_AUTOMONITOR) {*/
    if ((channeltype & (MT_POSITION | MT_ALARM | MT_AUTOMONITOR)) == 0) {
        if (entry->mttellen == 0 || entry->mttellen > SYS_TELLEN) return FALSE;