tools.c

来自「MCS51的实现无线接收发送（315M或433M)源程序代码。」· C语言 代码 · 共 404 行

/**********************************************************
*                  Tools.c                                *
**********************************************************/
#include "Sm5964.h"
#include "Struct.h"
#include "Tmr2.h"
#include "Tools.h"
//=========================================================
/*
BOOLEAN IsInRange(INT8U Data,INT8U Low,INT8U High)
{
   if((Data>=Low)&&(Data<=High)) return true;
   return false;
}
*/
//=========================================================
/*
BOOLEAN IsZero(INT8UX *Ptr,INT8U Len)
{
   for(;Len>0;Len--)
     {
      if(*Ptr==0) Ptr++;
      else return false;
     }
   return true;
}
*/
//=========================================================
INT8U HexToAscii(INT8U Ch)
{
   Ch&=0x0F;
   if(Ch<10) return (Ch+'0');
   else return (Ch-0x0A+'A');
}
//=========================================================
/*
INT8U AsciiToHex(INT8U Ch)
{
   if(IsInRange(Ch,'0','9')) return(Ch-'0');
   else if(IsInRange(Ch,'A','F')) return(Ch-'A'+0x0A);
   else if(IsInRange(Ch,'a','f')) return(Ch-'a'+0x0A);
   else return 0;
}
*/
//=========================================================
/*
INT8U TwoAsciiToHex(INT8UX *XPtr)
{
   INT8U Temp;
   
   Temp=AsciiToHex(*XPtr++);
   Temp*=16;
   Temp=Temp+AsciiToHex(*XPtr);
   return Temp;
}
*/
//=========================================================
/*
INT8U TwoAsciiToDec(INT8UX *XPtr)
{
   INT8U Temp;
   
   Temp=AsciiToHex(*XPtr++);
   Temp*=10;
   Temp=Temp+AsciiToHex(*XPtr);
   return Temp;
}
*/
//=========================================================
/*
INT16U ThreeAsciiToDec(INT8UX *XPtr)
{
   INT16U Temp;
   
   Temp=AsciiToHex(*XPtr++);
   Temp*=10;
   Temp=Temp+AsciiToHex(*XPtr++);
   Temp*=10;
   Temp=Temp+AsciiToHex(*XPtr);
   return Temp;
}
*/
//=========================================================
/*
INT8U BufHexToAscii(INT8UX *DPtr,INT8UX *CPtr,INT8U Len)
{
   INT8U i,STemp;
    
   for(i=0;i<Len;i++) 
     {
      STemp=*CPtr++;
      *DPtr++=HexToAscii(STemp>>4);
      *DPtr++=HexToAscii(STemp&0x0F);
     }
   return (2*Len);
}
*/
//=========================================================
/*
INT8U BufHexToDec(INT8UX *DPtr,INT8UX *CPtr,INT8U Len)
{
   INT8U i,STemp;
    
   for(i=0;i<Len;i++) 
     {
      STemp=*CPtr++;
      *DPtr++=HexToAscii(STemp/10);
      *DPtr++=HexToAscii(STemp%10);
     }
   return(2*Len);
}
*/
//=========================================================
/*
INT8U BufAsciiToHex(INT8UX *DPtr,INT8UX *CPtr,INT8U Len)
{
   INT8U i,DTemp,STemp;
    
   if(Len%2) return 0;
   Len/=2;
   for(i=0;i<Len;i++)
     {
      STemp=AsciiToHex(*CPtr++);
      DTemp=STemp<<4;
      *DPtr++=AsciiToHex(*CPtr++)|DTemp;
     }
   return Len;
}
*/
//=========================================================
void InitMemBuf(INT8UI *Ptr,INT8U Data,INT8U Len)
{
   for(;Len>0;Len--) *Ptr++=Data;
}
//=========================================================
void InitExMemBuf(INT8UX *Ptr,INT8U Data,INT8U Len)
{
   for(;Len>0;Len--) *Ptr++=Data;
}
//=========================================================
void MovXX(INT8UX *DPtr,INT8UX *SPtr,INT8U Len)
{
   for(;Len>0;Len--) *DPtr++=*SPtr++;
}
//=========================================================
void MovCX(INT8UX *DPtr,INT8UC *CPtr,INT8U Len)
{
   for(;Len>0;Len--) *DPtr++=*CPtr++;
}
//=========================================================
void ReverseX(INT8UX *DPtr,INT8U Len)
{
   INT8U Temp,HalfLen,i;
   
   if(Len<2) return;
   HalfLen=Len/2;
   for(i=0;i<HalfLen;i++)
     {
      Temp=DPtr[i];
      DPtr[i]=DPtr[Len-1-i];
      DPtr[Len-1-i]=Temp;
     }
}
//=========================================================
INT8U GetChkSum(INT8UX *DPtr,INT8U Len)
{
   INT8U Sum;

   for(Sum=0;Len>0;Len--) Sum+=*DPtr++;
   return Sum;
}
//=========================================================
/*
INT8U GetChkSumXor(INT8U *DPtr,INT8U Len)
{
   INT8U Sum;

   for(Sum=0;Len>0;Len--) Sum^=*DPtr++;
   return Sum;
}
*/
//=========================================================
/*
INT8U GetBig(INT8U Data1,INT8U Data2)
{
    if(Data1>Data2) return Data1;
    else return Data2;    
}
*/
//=========================================================
/*
INT8U GetSmall(INT8U Data1,INT8U Data2)
{
    if(Data1>Data2) return Data2;
    else return Data1;    
}
*/
//=========================================================
INT8U UpperChar(INT8U Ch)
{
   if(Ch>='a'&&Ch<='z') Ch='A'+(Ch-'a');
   return Ch;
}
//=========================================================
/*
INT8U LowerChar(INT8U Ch)
{
   if(Ch>='A'&&Ch<='Z') Ch='a'+(Ch-'A');
   return Ch;
}
*/
//=========================================================
/*
void UpperString(INT8UX *Ch,INT8U Len)
{
   for(;Len>0;Len--,Ch++) *Ch=UpperChar(*Ch);
}
*/
//=========================================================
/*
void LowString(INT8UX *Ch,INT8U Len)
{
   for(;Len>0;Len--,Ch++) *Ch=LowerChar(*Ch);
}
*/
//=========================================================
INT8U CmpChar(BOOLEAN MatchCase,INT8U Ch1,INT8U Ch2)
{
   if(MatchCase==false)
     {
      Ch1=UpperChar(Ch1);
      Ch2=UpperChar(Ch2);
     }
   if(Ch1>Ch2) return STR_GREAT;
   else if(Ch1<Ch2) return STR_LESS;
   else return STR_EQUAL;
}
//=========================================================
INT8U CmpXCString(INT8UX *Ptr1,INT8UC *Ptr2,INT16U Len)
{
   INT8U Result;
    
   while(1) 
     {
      if(Len==0) return STR_EQUAL;
      Result=CmpChar(true,*Ptr1++,*Ptr2++);
      if(Result!=STR_EQUAL) return Result;
      else Len--;
     }
}
//=========================================================
INT8U CmpString(INT8UX *Ptr1,INT8UX *Ptr2,INT16U Len)
{
   INT8U Result;
    
   while(1) 
     {
      if(Len==0) return STR_EQUAL;
      Result=CmpChar(true,*Ptr1++,*Ptr2++);
      if(Result!=STR_EQUAL) return Result;
      else Len--;
     }
}
//=========================================================
/*
BOOLEAN CmpCodeStr(INT8UX *XPtr,INT8UC *CPtr,INT8U XLen,INT8U CLen)
{
   INT8U Result;
   
   if(XLen!=CLen) return false;
   while(1) 
     {
      if(CLen==0) return true;
      Result=CmpChar(true,*XPtr++,*CPtr++);
      if(Result!=STR_EQUAL) return false;
      else CLen--;
     }
}
*/
//=========================================================
/*
INT8U CmpData(INT8UX *Buf1,INT8UX *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 SearchCDataInExMem(INT8UX *EPtr,INT8UX ELen,INT8UC *CPtr,INT8U CLen)
{
   INT8UC *TmpPtr;
   INT8U TempLen;
    
   if(CLen==0) return false;
   TmpPtr=CPtr,TempLen=CLen;
   for(;ELen>0;ELen--)
     {
      if(*EPtr++==*TmpPtr++) 
        {
         if(--TempLen==0) return true;
        } 
      else TmpPtr=CPtr,TempLen=CLen;
     }
   return false;
}
*/
//=========================================================
/*
BOOLEAN SearchKeyWord(INT8UX *Ptr,INT8U Len,INT8UC *CPtr)
{
   INT8UC *TmpPtr;

   if(*CPtr==0) return false;
   TmpPtr=CPtr;
   for(;Len>0;Len--) 
     {
      if(*Ptr++==*TmpPtr++) 
        {
         if(*TmpPtr==0) return true;
        } 
      else TmpPtr=CPtr;
     }
   return false;
}
*/
//=========================================================
/*
BOOLEAN SearchKeyWordFromHead(INT8UX *Ptr,INT8UC *CPtr)
{
   if(*CPtr==0) return false;
   while(*CPtr) 
     {
      if(*Ptr++!=*CPtr++) return false;
     }
   return true;
}
*/
//=========================================================
/*
INT8U FindCharPos(INT8UX *EPtr,INT8U FindChar,INT8U NumChar,INT8U MaxLen)
{
   INT8U Pos;
    
   if(MaxLen==0) return 0;
   Pos=0;
   while(1) 
     {
      if(*EPtr++==FindChar) 
        {
         if(NumChar==0) break;
         else NumChar--;
        }
      if(--MaxLen==0) break;
      else Pos++;
     }
   return Pos;
}
*/
//=========================================================
/*
BOOLEAN FindKeyWordCode(KeyEntryStruct code *Entry,INT8U KeyWordNum,INT8UX *Data,INT8U Len)
{
   INT8U i;
   
   for(i=0;i<KeyWordNum;i++)
     {
      if(SearchKeyWord(Data,Len,Entry->KeyWord))
        {
        	ExecFunc(Entry->ExecAddr);    	
         return true;
        }
      else Entry++;
     }
   return false;
}
*/
//=========================================================
/*
INT32U DegreeToSecond(INT8U *Data)
{
    INT32U Temp;
    
	   Temp=Data[0];
	   Temp=Temp*60;
	   Temp+=Data[1];
	   Temp=Temp*100;
	   Temp+=Data[2];
	   Temp=Temp*100;
	   Temp+=Data[3];
	   
	   return Temp;
}
*/
//=========================================================