tools.c

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

}

BOOLEAN Add_Thousand(INT16U *add1, INT16U *add2, INT8U len1, INT8U len2)
{
    INT8U tlen;
    INT16U *tadd;
    
    if (Adjust_Thousand(add1, len1)) return TRUE;
    if (Adjust_Thousand(add2, len2)) return TRUE;

    tadd = add1;
    tlen = len1;
    for (;; len1--, len2--) {
        if (len1 == 0 || len2 == 0) {
            if (len2 > 0) {
                for (; len2 > 0; len2--) {
                    if (*add2++ > 0) return TRUE;
                }
            }
            break;
        }
        *add1++ += *add2++;
    }
    
    return Adjust_Thousand(tadd, tlen);
}

BOOLEAN Dec_Thousand(INT16U *dec1, INT16U *dec2, INT8U len1, INT8U len2)
{
    INT16U carried, temp;
    
    if (Adjust_Thousand(dec1, len1)) return TRUE;
    if (Adjust_Thousand(dec2, len2)) return TRUE;
    
    carried = 0;
    for (;;) {
        if (len1 == 0) {
            if (len2 > 0) {
                for (; len2 > 0; len2--) {
                    if (*dec2++ > 0) return TRUE;
                }
            }
            if (carried)
                return TRUE;
            else
                return FALSE;
        }
        
        if (len2 > 0) {
            temp = *dec2 + carried;
        } else {
            temp = carried;
        }

        if (*dec1 < temp) {
            *dec1  += (1000 - temp);
            carried = 1;
        } else {
            *dec1  -= temp;
            carried = 0;
        }
        
        dec1++;
        len1--;
        if (len2 > 0) {
            dec2++;
            len2--;
        }
    }
}

void Mul_Thousand(INT16U *result, INT16U mul1, INT16U mul2)
{
    INT32U temp;
    
    temp = mul1 * mul2;
    result[0] = temp % 1000;
    result[1] = temp / 1000;
    if (result[1] > 999) result[1] = 999;
}

INT8U ThousandToAscii(INT8U *ptr, INT16U opdata)
{
    *ptr++  = HexToChar(opdata / 100);
    opdata %= 100;
    *ptr++  = HexToChar(opdata / 10);
    opdata %= 10;
    *ptr    = HexToChar(opdata);
    return 3;
}

#pragma O1
INT16U DeassembleByRules(INT8U *dptr, INT8U *sptr, INT16U len, ASMRULE_STRUCT *rule)
{
    INT16U rlen;
    INT8U  prechar, curchar, c_convert0;
    
    if (rule == NULL) return 0;
    c_convert0 = rule->c_convert0;
    rlen = 0;
    prechar = (~c_convert0);
    for (; len > 0; len--) {
        curchar = *sptr++;
        if (prechar == c_convert0) {
            if (curchar == rule->c_convert1) {            /* c_convert0 + c_convert1 = c_flags */
                prechar = (~c_convert0);
                *dptr++ = rule->c_flags;
                rlen++;
            } else if (curchar == rule->c_convert2) {     /* c_convert0 + c_convert2 = c_convert0 */
                prechar = (~c_convert0);
                *dptr++ = c_convert0;
                rlen++;
            } else {
                return 0;
            }
        } else {
            if ((prechar = curchar) != c_convert0) {
                *dptr++ = curchar;
                rlen++;
            }
        }
    }
    return rlen;
}

INT16U AssembleByRules(INT8U *dptr, INT8U *sptr, INT16U len, ASMRULE_STRUCT *rule)
{
    INT8U  temp;
    INT16U rlen;
    
    if (rule == NULL) return 0;
    
    *dptr++ = rule->c_flags;
    rlen    = 1;
    for (; len > 0; len--) {
        temp = *sptr++;
        if (temp == rule->c_flags) {            /* c_flags    = c_convert0 + c_convert1 */
            *dptr++ = rule->c_convert0;
            *dptr++ = rule->c_convert1;
            rlen += 2;
        } else if (temp == rule->c_convert0) {  /* c_convert0 = c_convert0 + c_convert2 */
            *dptr++ = rule->c_convert0;
            *dptr++ = rule->c_convert2;
            rlen += 2;
        } else {
            *dptr++ = temp;
            rlen++;
        }
    }
    *dptr = rule->c_flags;
    rlen++;
    return rlen;
}

BOOLEAN DateValid(DATE_STRUCT *date)
{
    if (date->year > 100) return FALSE;
    if (date->month > 12) return FALSE;
    if (date->day > 31) return FALSE;
    else return TRUE;
}

BOOLEAN TimeValid(TIME_STRUCT *time)
{
    if (time->hour > 24)   return FALSE;
    if (time->minute > 60) return FALSE;
    if (time->second > 60) return FALSE;
    else return TRUE;
}

BOOLEAN LongitudeValid(INT8U *longitude)
{
    if (longitude[0] > 180) return FALSE;
    if (longitude[1] > 60)  return FALSE;
    if (longitude[2] > 99)  return FALSE;
    if (longitude[3] > 99)  return FALSE;
    else return TRUE;
}

BOOLEAN LatitudeValid(INT8U *latitude)
{
    if (latitude[0] > 90) return FALSE;
    if (latitude[1] > 60) return FALSE;
    if (latitude[2] > 99) return FALSE;
    if (latitude[3] > 99) return FALSE;
    else return TRUE;
}
#if 1
BOOLEAN NeedRoundLine(INT8U *ptr, INT16U len)
{
    BOOLEAN isgbcode;
    
    for (isgbcode = FALSE; len > 0; ptr++, len--) {
        if (!isgbcode) {
            if (*ptr >= 0xa1) isgbcode = TRUE;
        } else {
            if (*ptr >= 0xa1) isgbcode = FALSE;
        }
    }
    return isgbcode;
}
#endif
INT16S PlotLinePos(INT8U *textptr, INT16U textlen, INT16U *linepos, INT16U maxline, INT16U linesize)
{
    INT16U pos, len, line;
    
    pos = line = len = linepos[0] = 0;
    if (textlen == 0) return 0;
    
    for (;;) {
        if (*textptr++ == '\n') {
            if (++line > maxline) return -1;
            len = 0;
            linepos[line] = ++pos;
        } else {
            pos++;
            if (++len == linesize) {
                if (NeedRoundLine(textptr - linesize, linesize)) {
                    pos--;
                    textptr--;
                }
                if (++line > maxline) return -1;
                len = 0;
                linepos[line] = pos;
            }
        }
        if (pos > textlen - 1) {
            if (len == 0) line--;
            break;
        }
    }
    return (line + 1);
}

INT16U InsertEditBuf(INT8U *ptr, INT16U len, INT16U pos, INT16U ch)
{
    INT16U i;
    INT8U  temp, *tempptr, ret;
    
    if (pos > len) return len;
    if (ch >= 0xA100) 
        ret = 2;
    else 
        ret = 1;
    for (;;) {
        tempptr = ptr + len;
        for (i = 1; i <= len - pos; i++) {
            temp       = *(tempptr - 1);
            *tempptr-- = temp;
        }
        if (ret == 2) 
            *tempptr = ch >> 8;
        else 
            *tempptr = ch;
        len++;
        pos++;
        if (--ret == 0) return len;
    }
}

INT8U DelEditBuf(INT8U *ptr, INT16U len, INT16U pos)
{
    INT16U j;
    INT8U  i, temp, *tempptr, ret;
    
    ret = 0;
    if (pos > len || pos == 0) return 0;
    if (ptr[pos - 1] >= 0xA1) 
        ret = 2;
    else 
        ret = 1;
    if (pos < ret) return 0;
    for (i = 1; i <= ret; i++) {
        tempptr = ptr + pos;
        for (j = 1; j <= (len - pos); j++) {
            temp           = *tempptr;
            *(tempptr - 1) = temp;
            tempptr++;
        }
        len--;
        pos--;
    }
    return ret;
}

void WriteWordByPointer(INT8U *ptr, INT16U wdata)
{
    *ptr++ = wdata >> 8;
    *ptr   = wdata;
}

INT16U ReadWordByPointer(INT8U *ptr)
{
    INT16U temp;
    
    temp  = *ptr++;
    temp  <<= 8;
    temp |= *ptr;
    return temp;
}

INT8U FormatYear(INT8U *ptr, INT8U year, INT8U month, INT8U day)
{
    if (year > 99) year = 99;
    if (month > 12 || month == 0) month = 12;
    if (day > 31 || day == 0) day = 1;
    *ptr++ = '2';
    *ptr++ = '0';
    DecToAscii(ptr, year, 2);
    ptr   += 2;
    *ptr++ = '.';
    DecToAscii(ptr, month, 2);
    ptr   += 2;
    *ptr++ = '.';
    DecToAscii(ptr, day, 2);
    return (2 + 2 + 1 + 2 + 1 + 2);
}

INT8U FormatTime(INT8U *ptr, INT8U hour, INT8U minute, INT8U second)
{
    minute += second / 60;
    second %= 60;
    hour   += minute / 60;
    minute %= 60;
    hour   %= 24;

    DecToAscii(ptr, hour, 2);
    ptr   += 2;
    *ptr++ = ':';
    DecToAscii(ptr, minute, 2);
    ptr   += 2;
    *ptr++ = ':';
    DecToAscii(ptr, second, 2);
    return (2 + 1 + 2 + 1 + 2);
}

//add by qzc
INT8U GetSmall(INT8U Data1,INT8U Data2)
{
  if(Data1<Data2) return Data1;
  else return Data2;
}

INT8U CmpData(INT8U *Buf1,INT8U *Buf2,INT8U Len1,INT8U Len2)
{
   INT8U Result;

   Result=CmpString(Buf1,Buf2,GetSmall(Len1,Len2));
   if(Result==STR_EQUAL)
     {
      if(Len1>Len2) return STR_GREAT;
      else if(Len1<Len2) return STR_LESS;
     }
   return Result;
}

BOOLEAN IsInRange(INT8U Data,INT8U Low,INT8U High)
{
   if((Data>=Low)&&(Data<=High)) return TRUE;
   return FALSE;
}

//(A In B=SUBCLASS)
INT8U RangeRelation(INT8U *A1,INT8U *A2,INT8U *B1,INT8U *B2,INT8U Len)
{
   if(CmpString(A1,A2,Len)==STR_GREAT) return VACUUM;
   if(CmpString(B1,B2,Len)==STR_GREAT) return VACUUM;

   switch(CmpString(A1,B1,Len))
     {
      case STR_LESS: if(CmpString(A2,B1,Len)==STR_LESS) return VACUUM;
                     return OVERLAP;
      case STR_GREAT:if(CmpString(A2,B2,Len)!=STR_GREAT) return SUBCLASS;
                     if(CmpString(A1,B2,Len)==STR_GREAT) return VACUUM;
                     return OVERLAP;
      case STR_EQUAL:if(CmpString(A2,B2,Len)==STR_GREAT) return OVERLAP;
                     return SUBCLASS;
      default:return MISS;
     }
}

#pragma O0
INT16U Code8_To_Code7(INT8U *Dptr,INT8U *Sptr,INT16U Len,INT16U LimitLen)
{
    INT8U i=0,j=7,Stemp=0,Dtemp=0;
    INT16U rLen=0;
    
    for(;;)
     {
        if(i==0)
         {
            if(Len==0)
             {
                if(rLen>=LimitLen)  return rLen=0;
                else
                 {
                    *Dptr=Dtemp;
                    rLen++;
                 }
                break;
             }
            i=8;
            Stemp=*Sptr++;
            Len--;
         }
        if(j==0)
         {
            if(rLen>=LimitLen) 
             {
                rLen=0;
                break;
             }
            j=7;
            *Dptr++ =Dtemp;
            Dtemp=0;
            rLen++;            
         }
        if (Stemp&mask[i-1]) Dtemp|=mask[j-1];
        i--;
        j--;
     }
    return rLen;
} 

INT16U Code7_To_Code8(INT8U *Dptr,INT8U *Sptr,INT16U Len)
{
    INT8U i=0,j=8,Stemp=0,Dtemp=0;
    INT16U rLen=0;
    
    for(;;)
     {        
        if(i==0)
         {
            if(Len==0) 
             {
                rLen=0;
                break;
             }
            i=7;
            Stemp=*Sptr++;
            Len--;
         }
        if(j==0)
         {
            j=8;
            *Dptr++ = Dtemp;
            rLen++;
            Dtemp=0;
            if(Len==0) break;
         }
        if(Stemp&mask[i-1])  Dtemp|=mask[j-1];
        i--;
        j--;
     }
    return rLen;
}



#pragma O1
INT8U BitValue(INT8U Data,INT8U Index)
{
   if((Data&mask[Index])==0) return 0;
   return 1;
}

BOOLEAN IsZero(INT8U *Ptr,INT8U Len)
{
   while(Len--)
     {
      if(*Ptr==0) Ptr++;
      else return FALSE;
     }
   return TRUE;
}