常用进制转换函数详细描述

记录一下对于常见字符或者进制转换的函数封装。

方式一： 

#ifndef _PUB_STRING_H_
#define _PUB_STRING_H_
#include <stdbool.h>
typedef unsigned int u32;
typedef unsigned short u16;
typedef unsigned char u8;
typedef int s32;
typedef short s16;
typedef char s8;

void String_DecimalToAscii(u32 data, u8 *string, u8 *length);
u16 String_GetSize(const u8 *str);
u32 String_Ascii16ToDecimal(const u8 *string, u8 length, bool *error_flag);
u32 String_Ascii10ToDecimal(const u8 *string, u8 length);
u32 String_Ascii2ToDecimal(const u8 *string, u8 length);
void String_HexToAscii(u8 data, u8 * string);
void String_AsciiToHex(u8 *data, const u8 string);
void String_HexArrayToAsciiArray(u8 *data, u8 *data1, u16 length);
void String_AsciiArrayToHexArray(u8 *data, u8 *data1, u16 length);
void String_CopyStr2ToStr1(u8 *str1, const u8 *str2, u16 length);
u32 String_InsertStr2toStr3AndStr1StoreStr1(u8 *str1, const u8 *str2, u8 *str3);
u32 String_InsertStr2toStr3AndStr1StoreStr2(const u8 *str1,  u8 *str2, const u8 *str3);
u32 String_InsertStr2toStr3AndStr1StoreStr4(u8 *str1, const u8 *str2, u8 *str3, u8 *str4);
u32 String_CopyStr2ToStr1NoLen(u8 *str1, const u8 *str2);
void String_AddStr2ToStr1(u8 *str1, u16 *str1length, const u8 *str2, u16 str2length);
u16 String_StrStr(const u8 *str1, u16 str1length, const u8 *str2);
u16 String_FindInStrBetweenStr1AndStr2(const u8 *str, u16 strlength, const u8 *str1, const u8 *str2, u8 *str3);
s8 String_Compare(const u8 *str1, const u8 *str2, u16 length);
u32 String_ChangeU8ToU32(u8 *buff);
void String_ChangeU32ToU8(u32 handle, u8 *buff);
u16 String_SkipColon(u16 quantity, const u8 *pdata, u16 length);
u16 String_SkipSlash(u16 quantity, const u8 *pdata, u16 length);

void String_Memset(u8 *buff, u8 num, u16 length);
u8 String_DecimalismToBinaryStr(u8 data, u8 *buff);
u16 ModBusCRC(u8* buff, u16 length);
#endif //end ifndef _STRING_H_

#include "PUB_string.h"
#include <string.h>
/*****************************************************
*名 称: String_DecimalToAscii
*功 能: 10进制数转换为ASCII形式,例如将110转换成31 31 30
*输 入: data: 需要转换的数据；
*      string: 转换后存放数据的首地址
*      length: 转换后的数据的长度
*输 出: NULL
*****************************************************/
void String_DecimalToAscii(u32 data, u8 *string, u8 *length)
{
    u8 i,offset;
    u32 y,div;

    offset = 0;
    if(data == 0)
    {
        *string = '0';
        *length = 1;
        return;
    }
    div = 1000000000;
    for(i=0; i<10; i++)
    {
        y = data/div;
        div /= 10;
        if(y>0 || i==9)
        {
            *(string + offset) = (y%10) + '0';
            offset++;
        }
    }
    *length = offset;
}

/*****************************************************
*名 称: String_GetSize
*功 能: 计算字符串长度
*输 入: str: 需要求长度的字符串首地址
*输 出: 计算后的长度
*****************************************************/
u16 String_GetSize(const u8 *str)
{
    u16 i;
    for(i=0; i<512; i++)
    {
        if(*(str+i) == '\0')
        {
            return i+1;
        }
    }
    return 0;
}

/*****************************************************
*名 称: String_Ascii16ToDecimal
*功 能: 将ASCII类型的16进制字符串转换成10进制的数据，例如将“3AC”转换成940
*输 入: string: 首地址
*      length: 长度
*输 出: 计算后的数据
*****************************************************/
u32 String_Ascii16ToDecimal(const u8 *string, u8 length, bool *error_flag)
{
    u8 i,s;
    u32 y,mul,sum;
    bool flag = false;

    y = 0;
    mul = 1;
    sum = 0;

    if(length == 0)
    {
        length = (u8)String_GetSize(string);
    }
    for(i = length; i>0; i--)
    {
        s = *(string + i -1);
        if((s>='0') && (s<='9'))
        {
            s -= '0';
            y = s*mul;
            sum += y;
            mul *= 16;
        }
        else if((s>='A') && (s<='F'))
        {
            s = s-'A'+10;
            y = s*mul;
            sum += y;
            mul *= 16;
        }
        else if((s>='a') && (s<='f'))
        {
            s = s-'a'+10;
            y = s*mul;
            sum += y;
            mul *= 16;
        }
        else
        {
            flag = true;
            break;
        }
    }
    *error_flag = flag;
    return sum;
}

/*****************************************************
*名 称: String_Ascii10ToDecimal
*功 能: 将ASCII类型的10进制字符串转换成10进制的数据，例如将“940”转换成940
*输 入: string: 首地址
*      length: 长度
*输 出: 计算后的数据
*****************************************************/
u32 String_Ascii10ToDecimal(const u8 *string, u8 length)
{
    u8 i,s;
    u32 y,mul,sum;

    y = 0;
    mul = 1;
    sum = 0;

    if(length == 0)
    {
        length = (u8)String_GetSize(string);
    }
    for(i = length; i>0; i--)
    {
        s = *(string + i -1);
        if( (s >= '0') && (s <= '9') )
        {
            s -= '0';
            y = s*mul;
            sum += y;
            mul *= 10;
        }
    }
    return sum;
}

/*****************************************************
*名 称: String_Ascii2ToDecimal
*功 能: 将ASCII类型的2进制字符串转换成10进制的数据，例如将“11000”转换成24
*输 入: string: 首地址
*      length: 长度
*输 出: 计算后的数据
*****************************************************/
u32 String_Ascii2ToDecimal(const u8 *string, u8 length)
{
    u8 i,s;
    u32 y,mul,sum;

    y = 0;
    mul = 1;
    sum = 0;

    if(length == 0)
    {
        length = (u8)String_GetSize(string);
        if(length>=8)
        {
            length = 8;
        }
    }
    for(i = length; i>0; i--)
    {
        s = *(string + i -1);
        if( (s >= '0') && (s <= '1') )
        {
            s -= '0';
            y = s*mul;
            sum += y;
            mul *= 2;
        }
    }
    return sum;
}

/*****************************************************
*名 称: String_HexToAscii
*功 能: 将一个字节的数据的低4位转换成ASCII形式输出
*输 入: data: 需要转换的数据
*      string: 首地址
*输 出: NULL
*****************************************************/
void String_HexToAscii(u8 data, u8 * string)
{
    u8 y;

    y = data & 0x0f;
    if(y>9)
    {
        *string = (y-10)+'A';
    }
    else
    {
        *string = y + '0';
    }
}

/*****************************************************
*名 称: String_AsciiToHex
*功 能: 将ASCII形式的数据转换成16进制
*输 入: data: 首地址
*      string: ASCII数据
*输 出: NULL
*****************************************************/
void String_AsciiToHex(u8 *data, const u8 string)
{
    if((string >= '0') && (string <= '9'))
    {
        *data = string  - '0';
    }
    else if((string >= 'A')&&(string <= 'F'))
    {
        *data = string  - 'A' + 10;
    }
    else if((string >= 'a') && (string <= 'f'))
    {
        *data = string - 'a' + 10;
    }
    else
    {
        *data = 0;
    }
}

/*****************************************************
*名 称: String_HexArrayToAsciiArray
*功 能: 将16进制的数组转换成ASCII形式的数组
*输 入: data: 需要转换的16进制数组的首地址
*      data1: 存放转换后的数据的首地址
*      length: 需要转换的数组的长度
*输 出: NULL
*****************************************************/
void String_HexArrayToAsciiArray(u8 *data, u8 *data1, u16 length)
{
    u16 i;
    u8 y;

    for(i=0; i<length; i++)
    {
        y = (*(data+i) >> 4);
        String_HexToAscii(y, data1+(i*2));

        y = (*(data+i) & 0x0f);
        String_HexToAscii(y, data1+(i*2)+1);
    }
}

/*****************************************************
*名 称: String_AsciiArrayToHexArray
*功 能: 将ASCII形式的数组转换成16进制的数组
*输 入: data: 需要转换的ASCII形式的数组的首地址
*      data1: 存放转换后的数据的首地址
*      length: 需要转换的数组的长度
*输 出: NULL
*****************************************************/
void String_AsciiArrayToHexArray(u8 *data, u8 *data1, u16 length)
{
    u16 i;
    u8 d,y;

    for(i=0; i<length; i++)
    {
        String_AsciiToHex(&y, *(data1+(i*2)));
        d = (y<<4)&0xf0;

        String_AsciiToHex(&y, *(data1+(i*2)+1));
        *(data+i) = d | (y&0x0f);
    }
}

方式二： 

/**
 * @brief ascii转换为hex
 * @param cNum 需要转换的字符
 * @return 返回转换的HEX值
 */
unsigned char AsciiToHex(unsigned char cNum);

/**
 * @brief 将字符串转换为HEX (Ascii码形式) "C8329BFD0E01" --> {0xC8, 0x32, 0x9B, 0xFD, 0x0E, 0x01}
 * @param ptr 字符串Ascii
 * @param pdst hex字符
 * @param len ptr字符长度
 */
void StrToHex(char *ptr, unsigned char *pdst,unsigned short len);

/**
 * @brief 16进制HEX转换为字符串 例如：{0xC8, 0x32, 0x9B, 0xFD, 0x0E, 0x01} --> "C8329BFD0E01"
 * @param pSrc HEX数据串
 * @param pDst 字符串
 * @param nSrcLength hex字符大小
 */
void Hex2Str(char* pSrc, char* pDst, unsigned int nSrcLength);

/**
 * @brief 字符串转为hex(字符串形式) (str:siter --> HEX:"7369746572")
 * @param Str 字符串
 * @param HexStr hex返回值
 */
void Str2HexStr(char *Str, char *HexStr);

/**
 * @brief 将hex字符串转为字符串 (HEX:"7369746572" ---> str:siter)
 * @param HexStr hex字符值
 * @param Str 字符串
 * @return 
 */
unsigned short HexStr2Str(char *HexStr, char *Str);

/**
 * @brief HEX字符串数转10进制数 "4d8db438"-->1301132344
 * @param source 16进制数的字符串
 * @return 成功：十进制数，失败：0
 */
long hexStrToDec(char *source);

/**
 * @brief 返回ch字符在sign数组中的序号 
 * @param ch 
 * @return 成功：序号 失败：-1
 */
int getIndexOfSigns(char ch);

/**
 * @brief 计算字符串长度
 * @param str 需要求长度的字符串首地址
 * @return 计算后的长度
 */
u16 String_GetSize(const u8 *str);

/**
 * @brief str1中查询是否存在str2
 * @param str1 str1首地址
 * @param str1length str1当前长度
 * @param str2 str2首地址
 * @return NULL
 */
u16 String_StrStr(const u8 *str1, u16 str1length, const u8 *str2);

 

// ascii转换为hex
unsigned char AsciiToHex(unsigned char cNum)
{
    if(cNum>='0'&&cNum<='9')
    {
        cNum -= '0';
    }
    else if(cNum>='A'&&cNum<='F')
    {
        cNum -= 'A';
        cNum += 10;
    }
    else if(cNum>='a'&&cNum<='f')
    {
        cNum -= 'a';
        cNum += 10;
    }
    return cNum;
}
// 将字符串Ascll转换为HEX
void StrToHex(char *ptr, unsigned char *pdst,unsigned short len)
{
    unsigned char n1 = 0;
    unsigned char n2 = 0;
    unsigned char num = 0;
    unsigned short i = 0;
    unsigned short index = 0;
 
    for (i = 0; i < len; i++)
    {
        index = i << 1;                //index=i*2
        n1 = AsciiToHex(ptr[index]);
        n2 = AsciiToHex(ptr[index + 1]);
        num = (n1 << 4) + n2;
        pdst[i] = num;
        
    }
 
}
// 16进制HEX转换为字符串
void Hex2Str(char* pSrc, char* pDst, unsigned int nSrcLength)
{
    int i = 0;
    const char tab[]="0123456789ABCDEF";    // 0x0-0xf的字符查找表
 
    for (i = 0; i < nSrcLength; i++)
    {
        *pDst++ = tab[*pSrc >> 4];        // 输出高4位
        *pDst++ = tab[*pSrc & 0x0f];    // 输出低4位
        pSrc++;
    }
 
    // 输出字符串加个结束符
    *pDst = '\0';
}
// 字符串转HEX (str:siter --> HEX:7369746572)
void Str2HexStr(char * Str,char * HexStr)
{
    int i =0;
    unsigned char dec;
    char * p = HexStr;
    unsigned char hex = 0;
    const char tab[]="0123456789ABCDEF";// 0x0-0xf的字符查找表
    for(i = 0;Str[i];i++)
    {
        dec = *(Str+i);//十进制表示一个ACCII
        hex = dec/16;
        *p = tab[hex];
        p++;
        hex = dec%16;
        *p = tab[hex];
        p++;
    }
    *p = 0;//最后一位赋值0
}

// hex字符串转为字符串 (HEX:7369746572 ---> str:siter)
unsigned short HexStr2Str(char * HexStr,char * Str)
{
    unsigned short i =0;
    char * p = Str;
    ESP_LOGW(TAG,"HexStr2Str HEX:%x\n",HexStr[0]);
    for(i = 0;HexStr[i]&&HexStr[i+1];i+=2,p++)
    {
        //高四位
        if((HexStr[i]<='9')&&(HexStr[i]>='0'))
        {
            *p = (HexStr[i]-'0')*16;
        }
        else if((HexStr[i]<='F')&&(HexStr[i]>='A'))
        {
            *p = (HexStr[i]-'A'+10)*16;
        }
        else if((HexStr[i]<='f')&&(HexStr[i]>='a'))
        {
            *p = (HexStr[i]-'a'+10)*16;
        }
        else//不符合格式，因为可能出现了除了0-9,a-f或者A-F之外的数据
            return 0;
        
        //低四位
        if((HexStr[i+1]<='9')&&(HexStr[i+1]>='0'))
        {
            *p += (HexStr[i+1]-'0');
        }
        else if((HexStr[i+1]<='F')&&(HexStr[i+1]>='A'))
        {
            *p += (HexStr[i+1]-'A'+10);
        }
        else if((HexStr[i+1]<='f')&&(HexStr[i+1]>='a'))
        {
            *p += (HexStr[i+1]-'a'+10);
        }
        else//不符合格式，因为可能出现了除了0-9,a-f或者A-F之外的数据
            return 0;
    }
    *p = 0;//最后一位赋值0
    return i/2;//返回数据的位数
}

/* HEX字符串数转10进制数 "4d8db438"-->1301132344*/
long hexStrToDec(char *source)
{
    long sum = 0;
    long t = 1;
    int i, len;
 
    len = strlen(source);
    for(i=len-1; i>=0; i--)
    {
        sum += t * getIndexOfSigns(*(source + i));
        t *= 16;
    }  
 
    return sum;
}
 
/* 返回ch字符在sign数组中的序号 */
int getIndexOfSigns(char ch)
{
    if(ch >= '0' && ch <= '9')
    {
        return ch - '0';
    }
    if(ch >= 'A' && ch <='F') 
    {
        return ch - 'A' + 10;
    }
    if(ch >= 'a' && ch <= 'f')
    {
        return ch - 'a' + 10;
    }
    return -1;
}

u16 String_GetSize(const u8 *str)
{
    u16 i;
    for(i=0; i<512; i++)
    {
        if(*(str+i) == '\0')
        {
            return i+1;
        }
    }
    return 0;
}

u16 String_StrStr(const u8 *str1, u16 str1length, const u8 *str2)
{
    u32 y,t,CompareState,str2length;

    str2length = String_GetSize(str2);
    if(str2length == 0)
    {
        return 0;
    }
    else
    {
        str2length--;
    }

    if(str1length < str2length)
    {
        return 0;
    }

    for(y=0; y<(str1length - str2length +1); y++)
    {
        CompareState = 0;
        for(t=0; t<str2length; t++)
        {
            if( *(str1+y+t) != *(str2+t) )
            {
                CompareState = 1;
                break;
            }
        }
        if(CompareState == 0)
        {
            return y+1;
        }
    }
    return 0;
}