tools.c

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

    if (dptr->month == 2 && (dptr->year % 4) == 0)
        curday = 29;
    else
        curday = CDAY[dptr->month - 1];

    if (tptr->second >= 60) {
        tptr->second -= 60;
        tptr->minute++;
    }
    if (tptr->minute >= 60) {
        tptr->minute -= 60;
        tptr->hour++;
    }
    tptr->hour += diftime;
    if (tptr->hour >= 24) {
        tptr->hour -= 24;
        dptr->day++;
    }
    if (dptr->day > curday) {
        dptr->day = 1;
        dptr->month++;
    }
    if (dptr->month > 12) {
        dptr->month = 1;
        dptr->year++;
    }
}

BOOLEAN SearchDataInMem(INT8U *bptr, INT16U blen, INT8U *sptr, INT16U slen)
{
    INT8U *tempptr;
    INT16U templen;
    
    if (slen == 0) return FALSE;
    tempptr = sptr;
    templen = slen;
    while(blen > 0) {
        if (*bptr++ == *tempptr++) {
            if (--templen == 0) return TRUE;
        } else {
            tempptr = sptr;
            templen = slen;
        }
        blen--;
    }
    return FALSE;
}

BOOLEAN SearchKeyWord(INT8U *ptr, INT16U maxlen, char *sptr)
{
    char *tmpptr;

    if (*sptr == 0) return FALSE;
    tmpptr = sptr;
   
    while(maxlen > 0) 
    {
        if (*ptr++ == *tmpptr++) 
        {
            if (*tmpptr == 0) return TRUE;
        }
        else 
        {
            tmpptr = sptr;
        }
        maxlen--;
    }
    return FALSE;
}

BOOLEAN SearchKeyWordFromHead(INT8U *ptr, INT16U maxlen, char *sptr)
{
    if (*sptr == 0) return FALSE;
    while(maxlen > 0) {
        if (*ptr++ == *sptr++) {
            if (*sptr == 0) return TRUE;
        } else {
            return FALSE;
        }
        maxlen--;
    }
    return FALSE;
}


#pragma O0
INT16U SearchDigitalString(INT8U *ptr, INT16U maxlen, INT8U flagchar, INT8U numflag)
{
    BOOLEAN find;
    INT16U  result;
    INT8U *bptr, *eptr;
    
    find = FALSE;
    for(;;) {
        if (maxlen == 0) {
            find = FALSE;
            break;
        }
        if (*ptr == flagchar) {
            numflag--;
            if (numflag == 0) {
                eptr = ptr;
                break;
            }
        }
        if (*ptr >= '0' && *ptr <= '9') {
            if (!find) {
                find = TRUE;
                bptr = ptr;
            }
        } else {
            find = FALSE;
        }
        ptr++;
        maxlen--;
    }
    
    if (find) {
        result = 0;
        for(;;) {
            result = result * 10 + CharToHex(*bptr++);
            if (bptr == eptr) break;
        }
    } else {
        result = 0xffff;
    }
    return result;
}

INT16U SearchString(INT8U *dptr, INT16U limitlen, INT8U *sptr, INT16U maxlen, INT8U flagchar, INT8U numflag)
{
    BOOLEAN find;
    INT16U  len;
    INT8U *bptr, *eptr;
    
    find = FALSE;
    for(;;) {
        if (maxlen == 0) {
            find = FALSE;
            break;
        }
        if (*sptr == flagchar) {
            if (!find) {
                find = TRUE;
                bptr = sptr;
            } else {
                numflag--;
                if (numflag == 0) {
                    eptr = sptr;
                    break;
                } else {
                    find = FALSE;
                }
            }
        }
        sptr++;
        maxlen--;
    }
    
    if (find) {
        len = 0;
        bptr++;
        while(bptr != eptr) {
            if (len >= limitlen) {
                len = 0;
                break;
            }
            *dptr++ = *bptr++;
            len++;
        }
        return len;
    } else {
        return 0;
    }
}



#pragma O1
INT16U FindCharPos(INT8U *sptr, char findchar, INT8U numchar, INT16U maxlen)
{
    INT16U pos;
    
    if (maxlen == 0) return 0;
    pos = 0;
    for (;;) 
    {
        if (*sptr++ == findchar) 
        {
            if (numchar == 0) break;
            else numchar--;
        }
        maxlen--;
        if (maxlen == 0) break;
        else pos++;
    }
    return pos;
}

BOOLEAN DecGpsData(INT8U *result, INT8U *data1, INT8U *data2)
{
    INT8U   cmpresult;
    BOOLEAN carried;
    INT8U *temp;
    
    cmpresult = CmpString(data1, data2, 4);
    if (cmpresult == STR_LESS) {
        temp  = data1;
        data1 = data2;
        data2 = temp;
    }
    
    if (data1[3] < data2[3]) {
        result[3] = (data1[3] + 100) - data2[3];
        carried   = TRUE;
    } else {
        result[3] = data1[3] - data2[3];
        carried   = FALSE;
    }
    
    if (data1[2] < (data2[2] + (INT8U)carried)) {
        result[2] = (data1[2] + 100) - (data2[2] + (INT8U)carried);
        carried   = TRUE;
    } else {
        result[2] = data1[2] - (data2[2] + (INT8U)carried);
        carried   = FALSE;
    }
    
    if (data1[1] < (data2[1] + (INT8U)carried)) {
        result[1] = (data1[1] + 60) - (data2[1] + (INT8U)carried);
        carried   = TRUE;
    } else {
        result[1] = data1[1] - (data2[1] + (INT8U)carried);
        carried   = FALSE;
    }
    
    if (data1[0] < (data2[0] + (INT8U)carried)) {
        result[0] = (data1[0] + 100) - (data2[0] + (INT8U)carried);
        carried   = TRUE;
    } else {
        result[0] = data1[0] - (data2[0] + (INT8U)carried);
        carried   = FALSE;
    }
    
    if (cmpresult == STR_LESS) return TRUE;
    else return FALSE;
}

void AddGpsData(INT8U *result, INT8U *data1, INT8U *data2)
{
    BOOLEAN carried;
    
    result[3] = data1[3] + data2[3];
    if (result[3] >= 100) {
        carried    = TRUE;
        result[3] -= 100;
    } else {
        carried    = FALSE;
    }
    
    result[2] = data1[2] + data2[2] + (INT8U)(carried);
    if (result[2] >= 100) {
        carried    = TRUE;
        result[2] -= 100;
    } else {
        carried    = FALSE;
    }
    
    result[1] = data1[1] + data2[1] + (INT8U)carried;
    if (result[1] >= 60) {
        carried    = TRUE;
        result[1] -= 60;
    } else {
        carried    = FALSE;
    }
    
    result[0] = data1[0] + data2[0] + (INT8U)carried;
}

BOOLEAN ShieldHighBit(INT8U *data)
{
    INT8U temp;
    
    temp = *data;
    if (temp == 0x00) temp = 0xff;
    else if (temp == 0x80) temp = 0xfe;
    
    *data = temp & 0x7f;
    if (temp & 0x80) return TRUE;
    else return FALSE;
}


static INT8U CodeTbl[] = { 0x2e, 0x2c, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,          /* .,012345 */
                           0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,          /* 6789ABCD */
                           0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c,          /* EFGHIJKL */
                           0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,          /* MNOPQRST */
                           0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62,          /* UVWXYZab */
                           0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,          /* cdefghij */
                           0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72,          /* klmnopqr */
                           0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a           /* stuvwxyz */
                         };


static INT8U Encode(INT8U data)
{
    return CodeTbl[data & 0x3f];
}

static INT8U Decode(INT8U data)
{
    INT8U i;
    
    for (i = 0; i < sizeof(CodeTbl); i++) {
        if (data == CodeTbl[i]) return i;
    }
    return 0xff;
}


#pragma O0
INT16U CodeX_To_Code6(INT8U mode, INT8U *dptr, INT8U *sptr, INT16U len, INT16U limitlen)
{
    INT8U  i, j, stemp, dtemp;
    INT16U rlen;
    
    if (len == 0) return 0;

    rlen  = 0;
    i     = 0;
    j     = 6;
    dtemp = 0;
    for (;;) {
        if (i == 0) {
            if (len == 0) {
                if (rlen >= limitlen) {
                    rlen = 0;
                } else {
                    *dptr = Encode(dtemp);
                    rlen++;
                }
                break;
            }
            if (mode == MODE_CODE8) i = 8;
            else i = 7;
            stemp = *sptr++;
            len--;
        }
        if (j == 0) {
            if (rlen >= limitlen) {
                rlen = 0;
                break;
            }
            j = 6;
            *dptr++ = Encode(dtemp);
            dtemp   = 0;
            rlen++;
        }
        if (stemp & mask[i - 1]) dtemp |= mask[j - 1];
        i--;
        j--;
    }
    return rlen;
}

INT16U Code6_To_CodeX(INT8U mode, INT8U *dptr, INT8U *sptr, INT16U len)
{
    INT8U  i, j, stemp, dtemp;
    INT16U rlen;
    
    rlen  = 0;
    i     = 0;
    dtemp = 0;
    if (mode == MODE_CODE8) j = 8;
    else j = 7;
    for (;;) {
        if (j == 0) {
            if (mode == MODE_CODE8) j = 8;
            else j = 7;
            *dptr++ = dtemp;
            rlen++;
            dtemp = 0;
            if (len == 0) break;
        }
        if (i == 0) {
            if (len == 0) {
                rlen = 0;
                break;
            }
            if ((stemp = Decode(*sptr++)) == 0xff) {
                rlen = 0;
                break;
            } else {
                i = 6;
                len--;
            }
        }
        if (stemp & mask[i - 1]) dtemp |= mask[j - 1];
        i--;
        j--;
    }
    return rlen;
}

#pragma O1
void EncodeTel(INT8U *dptr, INT8U *sptr, INT16U len, INT16U maxlen)
{
    if (len > maxlen) len = maxlen;
    for (; len > 0; len--, maxlen--) {
        *dptr++ = *sptr++;
    }
    for (; maxlen > 0; maxlen--) {
        *dptr++ = ' ';
    }
}

INT16U DecodeTel(INT8U *dptr, INT8U *sptr, INT16U len)
{
    INT16U rlen;
    
    rlen = 0;
    for (; len > 0; len--) {
        if (*sptr == ' ') break;
        *dptr++ = *sptr++;
        rlen++;
    }
    return rlen;
}

INT16U DecodeTellen(INT8U *sptr, INT16U len)
{
    INT16U rlen;
    
    rlen = 0;
    for (; len > 0; len--) {
        if (*sptr++ == ' ') break;
        rlen++;
    }
    return rlen;
}

BOOLEAN FindProcEntry(INT16U index, FUNCENTRY_STRUCT *funcentry, INT16U num)
{
    for (; num > 0; num--, funcentry++) {
        if (index == funcentry->index) {
            if (funcentry->entryproc != 0) {
                funcentry->entryproc();
                return TRUE;
            }
        }
    }
    return FALSE;
}


#pragma O0
static BOOLEAN Adjust_Thousand(INT16U *ptr, INT8U len)
{
    INT16U carried;
    
    carried = 0;
    for (; len > 0; len--) {
        *ptr += carried;
        if (*ptr > 999) {
            carried = *ptr / 1000;
            *ptr   %= 1000;
        } else {
            carried = 0;
        }
        ptr++;
    }

    if (carried) 
        return TRUE;
    else 
        return FALSE;