gpsrecer.c

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

                if (tmp == 0xff || tmp == 0) {
                    return;
                }
            }

            pos = FindCharPos(ptr, ',', 0, len);                        /* 搜索第一颗卫星号 */
            for (ct = 1; ct <= 5; ct++) {                               /* 最多搜索5颗卫星 */
                if (pos >= len) break;
                pos++;
                ptr += pos;
                len -= pos;
                if (*ptr == ',') {
                    break;
                } else {
                    index = SearchDigitalString(ptr, len, ',', 1);      /* 解析星号 */
                    if (index == 0xff) break;
                    if (index < sizeof(BKSatInf.SNR)) {
                        tmp = SearchDigitalString(ptr, len, ',', 2);    /* 解析仰角 */
                        if (tmp != 0xff) {
                            BKSatInf.elevation[index] = tmp;
                        }
                        tmpw = SearchDigitalString(ptr, len, ',', 3);   /* 解析方位角 */
                        if (tmpw != 0xffff) {
                            BKSatInf.azimuth[index] = tmpw;
                        }
                        tmp = SearchDigitalString(ptr, len, ',', 4);    /* 解析信噪比 */
                        if (tmp != 0xff) {
                            BKSatInf.SNR[index] = tmp;
                        }
                    }
                }
                pos = FindCharPos(ptr, ',', 3, len);                    /* 搜索下一颗卫星号 */
            }
        }
        if (t_msg == c_msg) {                                           /* 已获取完毕GSV消息 */
            memcpy(&SatInf, &BKSatInf, sizeof(SatInf));
            if (++gsv_cnt > 4) {////收到4次GSV做一次判断
                if ((num = GetGpsUsedNum(35)) > 3) {
                    gsv_status = GPS_PERFECT;
                    //SleepGps(); ////实际是否睡眠要看有无APPLYGPS
                } else if ((num = GetGpsUsedNum(30)) > 3) {
                    gsv_status = GPS_GOOD;
                   // SleepGps(); ////实际是否睡眠要看有无APPLYGPS
                } else {
                    gsv_status = GPS_BAD;
                    WakeupGps();
                }
                gsv_cnt = 0;
                
            }
        }
    }
}
#endif

void ResolvePUBX04(INT8U  *msgbuf, INT8U len)
{
    INT8U  pos, rlen;
    INT16U tmp;

    if (GpsDataValid()) {                                               /* 只有在GPS数据有效情况下, 才解析WEEK和TIME */
        pos = FindCharPos(msgbuf, ',', COMMA_GPSWEEK, len) + 1;         /* 解析GPS WEEK */
        if (msgbuf[pos] != ',') {                                       /* GPS WEEK不为空 */
            tmp = SearchDigitalString(&msgbuf[pos], 5, ',', 1);
            if (tmp != 0xffff) {
                gpsweek = tmp;
            }
        }
        pos = FindCharPos(msgbuf, ',', COMMA_TOW, len) + 1;             /* 解析GPS TIME */
        if (msgbuf[pos] != ',') {                                       /* GPS TIME不为空 */
            rlen = FindCharPos(&msgbuf[pos], '.', 0, sizeof(utc_tow));
            if (rlen <= sizeof(utc_tow)) {
                memset(utc_tow, '0', sizeof(utc_tow));
                memcpy(&utc_tow[sizeof(utc_tow) - rlen], &msgbuf[pos], rlen);
            }
        }
        StoreOldPosition();
    }
}
BOOLEAN GpsDataValid(void)
{
    if (GpsIsWorking()) {
        if (validflag == CHAR_VALID) return TRUE;
        else return FALSE;
    } else {
        return FALSE;
    }
}

INT8U GetVector(void)
{
    return c_vector;
}

INT8U GetDirection(void)
{
    return (c_direction / 3 + 1);
}

INT8U GetGpsTime(TIME_STRUCT *gpstime)
{
    memcpy((INT8U*)gpstime, (INT8U*)&c_time, sizeof(TIME_STRUCT));
    return sizeof(TIME_STRUCT);
}

INT8U GetGpsDate(DATE_STRUCT *gpsdate)
{
    memcpy((INT8U*)gpsdate, (INT8U*)&c_date, sizeof(DATE_STRUCT));
    return sizeof(DATE_STRUCT);
}

void GetLatitude(INT8U *ptr)
{
    memcpy(ptr, c_latitude, sizeof(c_latitude));
}

void GetLongitude(INT8U *ptr)
{
    memcpy(ptr, c_longitude, sizeof(c_longitude));
}

void ConvertDatumData(DATUM_STRUCT *datum)
{
    if (ShieldHighBit((INT8U*)&datum->vector)) datum->hbit |= 0x01;
    if (ShieldHighBit((INT8U*)&datum->longitude[0])) datum->hbit |= 0x02;
}

HWORD_UNION GetDatumData(DATUM_STRUCT *datum)
{
    HWORD_UNION result;


    datum->hbit = 0x40;
    if (!GpsDataValid()) datum->hbit |= 0x20;
    if (GetGpsViewNum()>0) datum->hbit |= 0x10;//卫星数大于1表示有卫星
    if (GetGpsFixMode()=='3') datum->hbit |= 0x08;//3D定位,否则为2D定位
   // if (GetCurShkStatus())  datum->hbit |= 0x04;//为true表示有震动.
    
    memcpy((INT8U*)datum->latitude,  (INT8U*)c_latitude,  sizeof(c_latitude));
    memcpy((INT8U*)datum->longitude, (INT8U*)c_longitude, sizeof(c_longitude));

    datum->vector       = GetVector();
    datum->direction    = GetDirection();

    result.bytes.low    = sizeof(DATUM_STRUCT);
    result.bytes.high   = GetChkSum(latitude, sizeof(latitude)) + GetChkSum(longitude, sizeof(longitude)) + GetChkSum(vector, sizeof(vector));
    return result;
}

INT16S GetGpsHeight(void)
{
    return height;
}

INT16U GetGpsWeek(void)
{
    return gpsweek;
}

INT8U GetGpsAsciiUTC(INT8U *ptr)
{
    memcpy(ptr, utc_tow, sizeof(utc_tow));
    return sizeof(utc_tow);
}

INT32U GetGpsUTC(void)
{
    INT8U   i;
    INT32U  tmp;
    BOOLEAN iszero;
    
    tmp    = 0;
    iszero = true;
    for (i = 0; i < sizeof(utc_tow); i++) {
        if (iszero) {
            if (utc_tow[i] == '0') {
                continue;
            } else {
                iszero = false;
            }
        }
        tmp = tmp * 10L + (utc_tow[i] - '0');
    }
    if (tmp > 0) {
        tmp = tmp * 1000L;
    }
    return tmp;
}

#if EN_GSV>0//////////////////////////////////////////////////////////BEGIN
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

INT8U GetGpsViewNum(void)//可见卫星数
{
    return SatInf.viewnum;
}

INT8U GSVStatus(void)
{
    return gsv_status;
}

INT8U GetGpsUsedNum(INT8U minsnr)
{
    INT8U i, used;
    
    for (i = 0, used = 0; i < sizeof(SatInf.SNR); i++) {
        if (SatInf.SNR[i] > minsnr) {                                   //信噪比超过设定值的卫星数
            used++;
        }
    }
    return used;
}

INT8U GetGpsSNR(INT8U index)
{
    if (index >= sizeof(SatInf.SNR)) {
        return 0xff;
    } else {
        return SatInf.SNR[index];
    }
}

INT16U GetGpsAzimuth(INT8U index)
{
    if (index >= sizeof(SatInf.azimuth)/sizeof(SatInf.azimuth[0])) {
        return 0xffff;
    } else {
        if (SatInf.azimuth[index] > 359 && SatInf.azimuth[index] != 0xffff) {
            return 0;
        } else {
            return SatInf.azimuth[index];
        }
    }
}

INT8U GetGpsElevation(INT8U index)
{
    if (index >= sizeof(SatInf.elevation)) {
        return 0xff;
    } else {
        if (SatInf.elevation[index] > 90 && SatInf.elevation[index] != 0xff) {
            return 90;
        } else {
            return SatInf.elevation[index];
        }
    }
}
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
#endif//////////////////////////////////////////////////////////END

INT8U GetGpsFixMode(void)/* 0:未，1：2D，2：3D定位 */
{      /* 定位模式，'1'：未定位，'2'：2D定位，'3'：3D定位 */

    return FixInf.mode;
}

INT8U GetGpsFixUsedStat(void)
{
    return FixInf.used;
}

INT8U GetGpsFixPDOP(void)
{
    return FixInf.PDOP;
}

BOOLEAN GpsFixIsValid(INT8U PDOP)
{
    if (FixInf.mode == '3' && FixInf.used >= 4 && FixInf.PDOP < PDOP) {
        return true;
    } else {
        return false;
    }
}


HWORD_UNION GetOffsetData1(DATUM_STRUCT *predatum, OFFSET1_STRUCT *offsetdata)
{
    INT8U hbit, tempresult[4];
    HWORD_UNION result;

    result = GetDatumData(&curdatum);
    hbit   = 0x0;

    if (DecGpsData(tempresult, (INT8U*)curdatum.latitude, (INT8U*)predatum->latitude))
        hbit |= 0x40;
    if (tempresult[0] > 0 || tempresult[1] > 0x03) {
        result.bytes.low = 0;
        return result;
    }
    hbit |= (tempresult[1] << 4);
    memcpy((INT8U*)offsetdata->vla_c, &tempresult[2], sizeof(offsetdata->vla_c));

    if (DecGpsData(tempresult, (INT8U*)curdatum.longitude, (INT8U*)predatum->longitude))
        hbit |= 0x08;
    if (tempresult[0] > 0 || tempresult[1] > 0x03) {
        result.bytes.low = 0;
        return result;
    }
    hbit |= (tempresult[1] << 1);
    memcpy((INT8U*)offsetdata->vlg_c, &tempresult[2], sizeof(offsetdata->vlg_c));

    offsetdata->vector    = curdatum.vector;
    offsetdata->direction = curdatum.direction;
    if (ShieldHighBit((INT8U*)&offsetdata->vector)) hbit |= 0x01;
    offsetdata->hbit      = hbit;
    memcpy((INT8U*)predatum, (INT8U*)&curdatum, sizeof(DATUM_STRUCT));

    result.bytes.low = sizeof(OFFSET1_STRUCT);
    return result;
}

void StoreOldPosition(void)
{

    if (GpsDataValid()) {
        prevalid = TRUE;
        memcpy((INT8U*)OldGpsPos.latitude,  latitude,  sizeof(OldGpsPos.latitude));
        memcpy((INT8U*)OldGpsPos.longitude, longitude, sizeof(OldGpsPos.longitude));
        StoreRamImage(RI_OLDGPSPOS_, (INT8U *)&OldGpsPos, sizeof(OLDGPSPOS_STRUCT));
        OldGpsPos.gpsweek = gpsweek;
        OldGpsPos.height  = height;
    } else {
        if (prevalid) {
            StorePubPara(OLDGPSPOS_);
        }
        prevalid = FALSE;
    }
}

void InitOldPosition(void)
{

    prevalid = FALSE;
    if (!ResumeRamImage(RI_OLDGPSPOS_, (INT8U *)&OldGpsPos, sizeof(OLDGPSPOS_STRUCT))) {
        if (!PubParaValid(OLDGPSPOS_)) {
            MovStr((INT8U*)OldGpsPos.latitude,  "0000.0000");
            MovStr((INT8U*)OldGpsPos.longitude, "00000.0000");
        }
    }

    validflag = CHAR_INVALID;
    ResolveGPRMC();
}

BOOLEAN GpsTimeError(void)
{
    if (GpsDataValid()) {
        if (c_date.year >= 19) return TRUE;
        else return FALSE;
    } else {
        return FALSE;
    }
}

BOOLEAN GpsDateValid(void)
{
    return datevalid;
}