tools.c

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

/****************************************************************
**                                                              *
**  FILE         :  Tools.C                                     *
**  COPYRIGHT    :  (c) 2001 .Xiamen Yaxon NetWork CO.LTD       *
**                                                              *
**                                                              *
**  By : CCH 2002.1.15                                          *
****************************************************************/

#include "structs.h"
//#include "system.h"
#include "tools.h"



/*
********************************************************************************
*                  DEFINE MASK
********************************************************************************
*/
static INT8U mask[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};


INT16U GetMod(INT16U tmp, INT8U t)
{
    INT8U  i;
    INT16U temp;
    
    i = t;
    temp =1;
     
    for(; i>0; i--)
    {
        temp *= 10;
    }
    
    return tmp % temp;
}

INT8U GetRs(INT16U mod, INT8U t)
{
    INT8U  i;
    INT16U temp;
    
    i= t;
    temp =1;
     
    for(; i>0;i--)
    {
        temp *= 10;
    }
    
    return mod / temp;

}

INT8U GetChkSum_IP(INT8U *dptr, INT16U len)   //yyy
{
    INT8U result;
	
    result = 0;
    while ( len > 0 ) {
    	if (*dptr == 0x19) {
    	 result += *dptr++;
    	 dptr++;      //跳过0X32
    	 len -= 2;
    	} else {
         result += *dptr++;
         len--;
        }
    }
    return result;
}

void MovXX(INT8U *dptr, INT8U *sptr, INT16U len)
{
    for (; len > 0; len--) {
        *dptr++ = *sptr++;
    }
}

void MovStr(INT8U *dptr, char *sptr)
{
    while(*sptr) {
        *dptr++ = *sptr++;
    }
}

void InitBuf(INT8U *dptr, INT8U initdata, INT16U len)
{
    for (; len > 0; len--) {
        *dptr++ = initdata;
    }
}

INT8U GetChkSum(INT8U *dptr, INT16U len)
{
    INT8U result;
	
    result = 0;
    for (; len > 0; len--) {
        result += *dptr++;
    }
    return result;
}

INT8U GetChkSum_N(INT8U *dptr, INT16U len)
{
    return (~GetChkSum(dptr, len));
}

INT8U GetChkSum_C(INT8U *dptr, INT16U len)
{
    HWORD_UNION result;
	
    result.hword = 0;
    for (; len > 0; len--) {
        result.hword += *dptr++;
        if (result.bytes.high > 0) {
            result.bytes.low += result.bytes.high;
            result.bytes.high = 0;
        }
    }
    return (result.bytes.low);
}

INT8U GetChkSum_7C(INT8U *dptr, INT16U len)
{
    INT8U result;
    
    result  = GetChkSum_C(dptr, len);
    result &= 0x7f;
    if (result == 0) result = 0x7f;
    return result;
}

void ConvertData(INT8U *dptr, INT16U len, INT8U ddata, INT8U sdata)
{
    for (; len > 0; len--) {
        if (*dptr == sdata) *dptr = ddata;
        dptr++;
    }
}

static INT8U UpperChar(INT8U ch)
{
    if (ch >= 'a' && ch <= 'z') 
        ch = 'A' + (ch - 'a');
    return ch;
}
/*
static INT8U LowerChar(INT8U ch)
{
    if (ch >= 'A' && ch <= 'Z')
        ch = 'a' + (ch - 'A');
    return ch;
}
*/
static INT8U CmpChar(BOOLEAN matchcase, INT8U ch1, INT8U ch2)
{
    if (matchcase != CASESENSITIVE) {
        ch1 = UpperChar(ch1);
        ch2 = UpperChar(ch2);
    }
    if (ch1 > ch2) return STR_GREAT;
    else if (ch1 < ch2) return STR_LESS;
    else return STR_EQUAL;
}

BOOLEAN CmpString_Byte(INT8U *ptr, INT16U len, INT8U cb)
{
    if (len == 0) return FALSE;
    for (; len > 0; len--) {
        if (*ptr++ != cb) return FALSE;
    }
    return TRUE;
}

INT8U CmpString(INT8U *ptr1, INT8U *ptr2, INT16U len)
{
    INT8U result;
    
    for (;;) {
        if (len == 0) return STR_EQUAL;
        result = CmpChar(CASESENSITIVE, *ptr1++, *ptr2++);
        if (result != STR_EQUAL) return result;
        else len--;
    }
}

INT8U ACmpString(BOOLEAN matchcase, INT8U *ptr1, INT8U *ptr2, INT16U len1, INT16U len2)
{
    INT8U result;
    
    for (;;) {
        if (len1 == 0 && len2 == 0) return STR_EQUAL;
        if (len1 == 0) return STR_LESS;
        if (len2 == 0) return STR_GREAT;
        
        result = CmpChar(matchcase, *ptr1++, *ptr2++);
        if (result != STR_EQUAL) return result;
        else {
            len1--;
            len2--;
        }
    }
}

INT16U Bit7ToOctet(INT8U *dptr, INT8U *sptr, INT16U len)
{
    INT8U  j, pos, stemp, dtemp;
    INT16U rlen;
    
    pos   = 0;
    rlen  = 0;
    dtemp = 0;
    for (; len > 0; len--) {
        stemp = *sptr++;
        for (j = 0; j <= 6; j++) {
            if (stemp & mask[j]) dtemp |= mask[pos];
            pos++;
            if (pos == 8) {
               *dptr++ = dtemp;
               pos   = 0;
               dtemp = 0;
               rlen++;
            }
        }
    }
    if (pos != 0) {
        *dptr = dtemp;
        rlen++;
    }
    return rlen;
}

INT16U OctetToBit7(INT8U *dptr, INT8U *sptr, INT16U len, INT8U leftbit)
{
    INT8U  j, pos, stemp, dtemp;
    INT16U rlen;
    
    pos   = 0;
    rlen  = 0;
    dtemp = 0;
    for (; len > 0; len--) {
        stemp = *sptr++;
        for (j = (8 - leftbit); j <= 7; j++) {
            if (stemp & mask[j]) dtemp |= mask[pos];
            pos++;
            if (pos == 7) {
                *dptr++ = dtemp;
                pos   = 0;
                dtemp = 0;
                rlen++;
                if (len == 1 && j != 0) break;
            }
        }
        leftbit = 8;
    }
    return rlen;
}

INT8U HexToChar(INT8U sbyte)
{
    sbyte &= 0x0F;
    if (sbyte < 0x0A) return (sbyte + '0');
    else return (sbyte - 0x0A + 'A');
}

INT8U CharToHex(INT8U schar)
{
    if (schar >= '0' && schar <= '9') return (schar - '0');
    else if (schar >= 'A' && schar <= 'F') return (schar - 'A' + 0x0A);
    else if (schar >= 'a' && schar <= 'f') return (schar - 'a' + 0x0A);
    else return 0;
}

INT8U SemiOctetToChar(INT8U sbyte)
{
    sbyte &= 0x0F;
    switch(sbyte)
    {
        case 0x0A:
            return '*';
        case 0x0B:
            return '#';
        case 0x0C:
            return 'a';
        case 0x0D:
            return 'b';
        case 0x0E:
            return 'c';
        case 0x0F:
            return 0;
        default:
            return (sbyte + '0');
    }
}

INT8U CharToSemiOctet(INT8U schar)
{
    if (schar >= '0' && schar <= '9') return (schar - '0');
    switch(schar)
    {
        case '*':
            return 0x0A;
        case '#':
            return 0x0B;
        case 'a':
            return 0x0C;
        case 'b':
            return 0x0D;
        case 'c':
            return 0x0E;
        default:
            return 0x0F;
    }
}

INT16U HexToAscii(INT8U *dptr, INT8U *sptr, INT16U len)
{
    INT16U i;
    INT8U  stemp;
    
    for (i = 1; i <= len; i++) {
        stemp = *sptr++;
        *dptr++ = HexToChar(stemp >> 4);
        *dptr++ = HexToChar(stemp & 0x0F);
    }
    return (2 * len);
}

INT16U HexToDec(INT8U *dptr, INT8U *sptr, INT16U len)
{
    INT16U i;
    INT8U  stemp;
    
    for (i = 1; i <= len; i++) {
        stemp = *sptr++;
        *dptr++ = HexToChar(stemp / 10);
        *dptr++ = HexToChar(stemp % 10);
    }
    return (2 * len);
}


INT16U AsciiToHex(INT8U *dptr, INT8U *sptr, INT16U len)
{
    INT16U i;
    INT8U  dtemp, stemp;
    
    if (len % 2) return 0;
    len /= 2;
    for (i = 1; i <= len; i++) {
        stemp   = CharToHex(*sptr++);
        dtemp   = stemp << 4;
        *dptr++ = CharToHex(*sptr++) | dtemp;
    }
    return len;
}

/* SAMPLE: 7899 -----> '7','8','9','9' */
INT8U DecToAscii(INT8U *dptr, INT32U data, INT8U reflen)
{
    INT8U i, len, temp;
    INT8U *tempptr;
    
    len     = 0;
    tempptr = dptr;
    for (;;) {
        *dptr++ = HexToChar(data % 10);
        len++;
        if (data < 10) break;
        else data /= 10;
    }
    if (len != 0) {
        dptr = tempptr;
        for (i = 0; i < (len/2); i++) {
            temp = *(dptr + i);
            *(dptr + i) = *(dptr + (len - 1 - i));
            *(dptr + (len - 1 - i)) = temp;
        }
        if (reflen > len) {
            dptr = tempptr + (len - 1);
            for (i = 1; i <= reflen; i++) {
                if (i <= len) *(dptr + (reflen - len)) = *dptr;
                else *(dptr + (reflen - len)) = '0';
                dptr--;
            }
            len = reflen;
        }
    }
    return len;
}

/* SAMPLE: '7','8','9','9' -----> 7899 */
INT16U AsciiToDec(INT8U *sptr, INT8U len)
{
    INT16U result;
    
    result = 0;
    for (; len > 0; len--) {
        result = result * 10 + CharToHex(*sptr++);
    }
    return result;
}

INT16U SemiOctetToAscii(INT8U *dptr, INT8U *sptr, INT16U len)
{
    INT16U rlen;
    INT8U  stemp, temp;
    
    rlen = 0;
    for (; len > 0; len--) {
        stemp = *sptr++;
        if ((temp = SemiOctetToChar(stemp)) == 0) break;
        else {
            *dptr++ = temp;
            rlen++;
            stemp >>= 4;
            if ((temp = SemiOctetToChar(stemp)) == 0) break;
            else {
                *dptr++ = temp;
                rlen++;
            }
        }
    }
    return rlen;
}

void SemiOctetToHex(INT8U *dptr, INT8U *sptr, INT16U len)
{
    INT8U stemp, temp;
    
    for (; len > 0; len--) {
        stemp   = *sptr++;
        temp    = stemp >> 4;
        stemp  &= 0x0F;
        *dptr++ = stemp*10 + temp;
    }
}

INT16U AsciiToSemiOctet(INT8U *dptr, INT8U *sptr, INT16U len)
{
    INT16U  rlen;
    INT8U   stemp, dtemp;
    BOOLEAN isodd;
    
    rlen   = 0;
    isodd  = TRUE;
    for (; len > 0; len--) {
        stemp = *sptr++;
        if ((stemp = CharToSemiOctet(stemp)) == 0x0F) break;
        if (isodd) {
            isodd = FALSE;
            dtemp = stemp;
        } else {
            isodd   = TRUE;
            stemp <<= 4;
            *dptr++ = dtemp | stemp;
            rlen++;
        }
    }
    if (!isodd) {
        *dptr = dtemp | 0xF0;
        rlen++;
    }
    return rlen;
}

static INT8U CDAY[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

void GetLocalTimeFromGMT(DATE_STRUCT *dptr, TIME_STRUCT *tptr, INT8U diftime)
{
    INT8U curday;