常用转换接口实现

//常用转换宏

#define LOW_BYTE(x)        ((x) & 0x0f)
#define HIGH_BYTE(x)    (((x) >> 4) & 0x0f)
#define LOW_WORD(x)     ((x) &0xFF )
#define HIGH_WORD(x)    (((x)>>8)&0xFF )

#define BCD_TO_HEX(x) (((x)>'9')?((x)-'7'):((x)-'0') )
#define ASC_TO_HEX(x)    (((x)>'9') ? ((x)-'7'):((x)-'0'))
#define HEX_TO_ASC(x)    (((x)>9)?(((x) & 0x0f) + '7'):(((x) & 0x0f) + '0'))

 

//常用转换接口

void utils_Demcint2string(unsigned int value, unsigned int count, unsigned char* ptr2)
{
    unsigned char *ptr;
    unsigned char Dectime=0;
    unsigned int times10=0;
    unsigned int i;
    ptr = ptr2;
    do
    {
        times10=1;
        for(i=0;i<(count-1);i++)
        {

            times10 *=10;
        }
        Dectime= (unsigned char)(value /times10);
        *ptr++ = Dectime+0x30;
        value =value - times10*Dectime;
    }while(--count);
}

 
 void utils_stringToint(unsigned int *value, unsigned int count, unsigned char* ptr2)
 {
     unsigned char *ptr;
     unsigned char Dectime=0;
     ptr = ptr2;
     *value=0;
     do
     {

         Dectime=(*ptr++)-0x30;
         (*value)=(*value)*10+Dectime;
     }while(--count);
 }
 
/**********************************************************************************
 * Function Name ：XorAlgorithm
 * Description   ：Data xor and
 * Input         input1 --  datat 1; input2 --  datat 2
 *                 len -- data length
 * Output        ：output
 * Return        : None
 * Ver&Timer     : V1.0.1; 2015-06-09
***********************************************************************************/
void XorAlgorithm(unsigned char *input1,unsigned char *input2,unsigned char *output,unsigned int len)
{
    unsigned char *xor1,*xor2,*result;
    xor1 = input1;
    xor2 = input2;
    result = output;

    while (len)
    {
             *result++ = *xor1++ ^ *xor2++;
             len--;
    }
}

/**********************************************************************************
 * Function Name ：ConvHEXTo2xAsc
 * Description   ：HEX data covert to ASCII code
 * Input           pcharhex --  input HEX data
 *                 len -- data length
 * Output        ：ipcharasc -- output ASCII code;
 * Return        : result data lenght

***********************************************************************************/
unsigned int ConvHEXTo2xAsc(unsigned char* pcharasc,unsigned char *pcharhex,unsigned int len )
{
  unsigned int iadd;
    unsigned char *pasc;
    unsigned char *phex;

    if((pcharasc == NULL)||(pcharhex == NULL))
        return 0;

    pasc = pcharasc;
    phex = pcharhex;

    for(iadd=0; iadd<len; iadd++)
    {
        pasc[2*iadd] = HIGH_BYTE(phex[iadd]);
        pasc[2*iadd+1] = LOW_BYTE(phex[iadd]);
    }

    for(iadd=0; iadd<len*2; iadd++)
    {
        pasc[iadd] = HEX_TO_ASC(pasc[iadd]);
    }

    return len*2;
}

/**********************************************************************************
 * Function Name ：ConvAsc2xToHEX
 * Description   ：HEX data covert to ASCII code
 * Input           pcharasc --  input ASCII code
 *                 len -- data length
 * Output        ：pcharhex -- output HEX data;
 * Return        : result data length
***********************************************************************************/
unsigned int ConvAsc2xToHEX(unsigned char* pcharhex, unsigned char* pcharasc, unsigned int len )
{
    unsigned int iadd;
    unsigned char ch1,ch2;
    unsigned char *pasc,*phex;

    if((pcharasc == NULL)||(pcharhex == NULL))
    {
        return 0;
    }

    pasc = pcharasc;
    phex = pcharhex;

    for(iadd=0; iadd<len*2; iadd+=2)
    {
            if ((pasc[iadd] >= 'a') && (pasc[iadd] <= 'f'))
            {
                    ch1 = pasc[iadd]-'a'+10;
            }
            else if ((pasc[iadd] >= 'A') && (pasc[iadd] <= 'F'))
            {
                    ch1 = pasc[iadd]-'A'+10;
            }
            else if ((pasc[iadd] >= '0') && (pasc[iadd] <= '9'))
            {
                    ch1 = pasc[iadd]-'0';
            }
            else
            {
                    ch1=0;
            }

            if ((pasc[iadd+1] >= 'a') && (pasc[iadd+1] <= 'f'))
            {
                    ch2 = pasc[iadd+1]-'a'+10;
            }
            else if ((pasc[iadd+1] >= 'A') && (pasc[iadd+1] <= 'F'))
            {
                    ch2 = pasc[iadd+1]-'A'+10;
            }
            else if ((pasc[iadd+1] >= '0') && (pasc[iadd+1] <= '9'))
            {
                    ch2 = pasc[iadd+1]-'0';
            }
            else
            {
                    ch2 = 0;
            }

            phex[iadd/2] = (ch1 << 4)+(ch2 & 0x0f);
    }

    return len;
}

/**********************************************************************************
 * Function Name ：Crc_Calculate16by8
 * Description   ：crc-16 calculate
 * Input         ptr -- char string;
 *                 count -- data length
 * Output        ：None
 * Return        : Crc-16 value
***********************************************************************************/
unsigned short Crc_Calculate16by8(unsigned char* ptr, unsigned short count)
{
    unsigned short j ;
    unsigned char i,b;
    unsigned short crcValue;

    crcValue =0;
    for (j=0; j<count; j++)
    {
            b= ptr[j];
            for (i=0; i<8; i++)
            {
                crcValue = ((b ^ (unsigned char)crcValue) & 1) ? ((crcValue >> 1) ^ 0xA001) : (crcValue >> 1);
                b >>= 1;
            }
    }

    return      crcValue;
}

/**********************************************************************************
 * Function Name ：LRCAlgorithm
 * Description   ：crc-16 calculate
 * Input         ptr -- char string;
 *                 iLen -- data length
 * Output        ：None
 * Return        : lrc value
***********************************************************************************/
unsigned char LRCAlgorithm(unsigned char *ptr, unsigned int iLen)
{
  unsigned int iadd = 0;
    unsigned char  cLRC = 0;

    if(ptr == NULL)
    {
        return 0;
    }

    for(iadd=0; iadd<iLen; iadd++)
    {
        cLRC ^= ptr[iadd];
    }

    return (cLRC & 0xff);
}

/**********************************************************************************
 * Function Name ：Check_numeric
 * Description   ：Check input char string numeric
 * Input         Checkdata -- char string;
 *                 iLength -- data length
 *                 dec -- data formate
 * Output        ：None
* Return         : Result: Ture or FALSE
***********************************************************************************/
unsigned char Check_numeric(unsigned char *pCheckdata, unsigned int iLength, unsigned char dec)
{
    unsigned int i;

    if(dec == 10)
    {
        for(i=iLength; i>0; i--)
        {
            if ( (pCheckdata[i-1] >= '0')&&(pCheckdata[i-1] <= '9'))
            {
                continue;
            }
            else
            {
                return FALSE;
            }
        }
    }
    else if(dec == 16)
    {
        for(i=iLength; i>0; i--)
        {
            if ( ((pCheckdata[i-1] >= 'A') && (pCheckdata[i-1] <= 'F')) \
                || ((pCheckdata[i-1] >= '0') && (pCheckdata[i-1] <= '9')))
            {
                continue;
            }
            else
            {
                return FALSE;
            }
        }
    }
    else if(dec == 2)
    {
        for(i=iLength; i>0; i--)
        {
            if ( pCheckdata[i-1] <= 0xFF )
            {
                  continue;
            }
            else
            {
                  return FALSE;
            }
        }
    }

  return TRUE;
}

unsigned int ultils_itoa(unsigned int value, unsigned char * strAscii, unsigned int radix)
{
    unsigned char *tp = strAscii;
    unsigned char  i = 0;
    unsigned int v = value;
    unsigned int iCount = 0;

    if ((radix > 36) || (radix <= 1))
    {
        return 0;
    }

    while (v || (tp == strAscii)) // if  v == 0 need tp == strAscii condition
    {
        i = (unsigned char)(v % radix);
        v = v / radix;
        if (i < 10)
        {
            *tp++ = i+'0';
        }
        else
        {
            *tp++ = i + 'a' - 10;
        }

        iCount ++;
    }

    return iCount;
}

/***************************************************************************
函数名: Usermemset
功能  : 为防止编译器优化memset,自定义memset函数
输入:
        pData    -- 指针，首地址
        cVal     -- 设定的值
        iDataLen -- 设定的字节数
输出:无
返回值:
        TRUE  -- 执行失败
        FALSE -- 执行成功
修改记录:
***************************************************************************/
bool Usermemset(void *pData, const unsigned char cVal, unsigned int iDataLen)
{
    unsigned char* cpSrc = NULL;  

    if((pData == NULL) || (iDataLen == 0))
    {
        return TRUE;
    }

    cpSrc =(unsigned char*)pData;
 
    while(iDataLen--)
    {  
        *(cpSrc++) = cVal;    
    } 

    return FALSE;
}

/***************************************************************************
函数名: Usermemcmp
功能  : 内存值比较，功能相当于memcmp
输入:
        pSrc1     -- 指针，待比较数据1首地址
        pSrc2     -- 指针，待比较数据2首地址
        iDataLen -- 设定的字节数
输出:无
返回值:
        TRUE  -- 比较结果不相等
        FALSE -- 比较结果相等
修改记录:
***************************************************************************/
bool Usermemcmp(void *pSrc1, void *pSrc2, const unsigned int iDataLen)
{
    unsigned char *cpSrc1 = NULL;
    unsigned char *cpSrc2 = NULL;
    unsigned int iCount = 0;
    unsigned int iTmpLen = iDataLen;

    if((pSrc1 == NULL) || (pSrc2 == NULL))
    {
        return TRUE;
    }

    cpSrc1 = (unsigned char *)pSrc1;
    cpSrc2 = (unsigned char *)pSrc2;

    while(iTmpLen--)
    {
        if(*(cpSrc1++) == *(cpSrc2++))
        {
            iCount++;
        }
    }

    return (iCount == iDataLen)?FALSE:TRUE;
}

/**********************************************************************************
 * Function Name ：Calc_Accumulate
 * Description   ：Calculate every byte accumulation 
 * Input         ptr -- char string;
 *                 ptrLen -- data length
 * Output        ：None
 * Return        : accumulation value
 * Ver&Timer     : V1.0.1; 2015-06-09
***********************************************************************************/
unsigned char Calc_Accumulate(unsigned char *ptr,  unsigned int ptrLen)
{
    unsigned int iadd;
    
      unsigned short accval = 0x00;
    
        if(ptr == NULL)
        {
              return 0;
        }
        
        for(iadd = 0; iadd < ptrLen; iadd ++)
        {
              accval += ptr[iadd];
              accval &= 0x00FF;
        }
        
        return (unsigned char)(accval&0x00FF);
}

/**********************************************************************************
 * Function Name ：Multiples_of_Eight
 * Description   ：补齐8的倍数
 * Input         ptr -- 需要补齐的数组指针
 *                 ptrLen --数组的长度
 * Output        ：None
 * Return        : None
 * Ver&Timer     : V1.0.1; 2017-07-23
***********************************************************************************/
void Multiples_of_Eight(unsigned char *pptr,unsigned int *ptrLen)
{
     if((*ptrLen)&0x07)
     {
                  Usermemset(pptr+(*ptrLen), 0x00, 8-((*ptrLen)&0x07));
                  (*ptrLen) += (8-(*ptrLen)&0x07);
     }
}