【小资源单片机转换拷贝字符转换等函数持续更新...】

呀哈！高

已于 2023-06-03 11:52:50 修改

阅读量122

点赞数

文章标签：单片机嵌入式硬件

于 2023-05-28 16:11:14 首次发布

本文链接：https://blog.csdn.net/qq_36296398/article/details/130913693

版权

小资源单片机转换拷贝字符转换等函数

将小写字母转为大写并删除空格

/**
*  将小写字母转为大写并删除空格
*@param 	[IN]src: 原始字符串
*@param 	[OUT]des: 目标地址
*@return	无
*/
static void lower2upper_and_remove_spaces(uint8_t *src,  uint8_t *des)
{
    do
    {
        if(*src >= 'a' && *src <= 'z')
        {
            *des++ = *src - 'a' + 'A';
        }
        else if(' ' != *src)
        {
            *des++ = *src;
        }
        
    }while(*src++);	
}

查找一个字符串是否在另一个字符串中出现

/**
*  查找一个字符串是否在另一个字符串中出现
*@param 	s: 原始字符串
*@param 	d: 要查找的字符串
*@return	返回查找的结果
*@retval		NULL: d字符串未出现在s字符串
*@retval		s:    d字符串出现在s字符串,且返回当前指针s所指向的地址
*/
uint8_t* find_string(uint8_t *s, uint8_t *d)
{
    uint8_t *tmp;
    
    while(0 != *s && 0 != *d)
    {
        tmp = d;
        while(*s == *tmp && *s && *tmp)
        {
            s++;
            tmp++;
        }
        
        if(0 == *tmp)
        {
            return s;
        }
        s++;
    }
    return NULL;
}

截取指定开头和结尾的中间字符

/**
*  截取指定开头和结尾的中间字符
*@param		str: 原始字符串
*@param 	s: 开始字符串
*@param		e: 结尾字符串
*@param		res: 截取到的字符串
*/
static void match_string(uint8_t *str, uint8_t *s, uint8_t *e, uint8_t *res)
{
    uint8_t *first_result = NULL;
    uint8_t *f_t = NULL, *tmp = NULL;
    uint8_t i = 0, t_i = 0, result_flag = 0;

    first_result = find_string(str, s);

    if(NULL != first_result)
    {
        f_t = first_result;
        while(0 != *f_t && 0 != *e)
        {
            tmp = e;
            t_i = 0;
            while(*f_t == *tmp && *f_t && *tmp)
            {
                f_t++;
                tmp++;
                t_i++;
            }

            if(0 == *tmp)
            {
				result_flag = 1;
                break;
            }
            else if(t_i > 0)
            {
                f_t--;
                t_i--;
            }

            f_t++;
            i += t_i + 1;
        }

        while(i > 0 && result_flag)
        {
            *res = *first_result;
            res ++;
            first_result ++;
            i--;
        }
    }
}

十六进制字符串转整数

/**
*  十六进制字符串转整数
*@param		s: 十六进制字符串
*@param 	s: 转换字符的升序
*@return	整数结果
*/
static uint32_t htoi(uint8_t s[], uint8_t size)  
{  
    uint8_t i = 0;  
    uint32_t  n = 0;  
	
	
    for (i = 0; i < size; i++)  
    {  
		s[i] = s[i] >= 'A' && s[i] <= 'Z' ? s[i] + 'a' - 'A' : s[i];

		if((s[i] >= '0' && s[i] <= '9') || (s[i] >= 'a' && s[i] <= 'z'))
		{
			if (s[i] > '9')  
			{
				n = (n << 4) + (10 + s[i] - 'a');  
			}
			else  
			{  
				n = (n << 4) + (s[i] - '0');  
			} 			
		}
		else
		{
			break;
		}
    }

    return n;  
}

数组转字符串


int arrayToStr(unsigned char *buf, unsigned int buflen, char *out)
{
		char strBuf[33] = {0};
		char pbuf[32];
		int i;
		for(i = 0; i < buflen; i++)
		{
				sprintf(pbuf, "%02X", buf[i]);
				strncat(strBuf, pbuf, 2);
		}
		strncpy(out, strBuf, buflen * 2);
		return buflen * 2;
}

字符串转HEX

  int StringToHex(char *str, unsigned char *out, unsigned int *outlen)
  {
      char *p = str;
      char high = 0, low = 0;
      int tmplen = strlen(p), cnt = 0;
      tmplen = strlen(p);
      while(cnt < (tmplen / 2))
      {
          high = ((*p > '9') && ((*p <= 'F') || (*p <= 'f'))) ? *p - 48 - 7 : *p - 48;
         low = (*(++ p) > '9' && ((*p <= 'F') || (*p <= 'f'))) ? *(p) - 48 - 7 : *(p) - 48;
         out[cnt] = ((high & 0x0f) << 4 | (low & 0x0f));
         p ++;
         cnt ++;
     }
     if(tmplen % 2 != 0) out[cnt] = ((*p > '9') && ((*p <= 'F') || (*p <= 'f'))) ? *p - 48 - 7 : *p - 48;
     
     if(outlen != NULL) *outlen = tmplen / 2 + tmplen % 2;
     return tmplen / 2 + tmplen % 2;
 }

字符串取出正负数据

uint32_t CSQ_Data_Deal(char *star)
{
	uint32_t data=0;
	if(NULL != star)
	{
		for(;*star!='\r';star++)//1100
		{
				data=data*10+((*star-'0'));	//①0*10+1 1  ②1*10+1 11 ③11*10+0 110 ④110*10+0 1100
		}
	}
	
	return data;
}
int NUESTATS_Data_Deal(char *star)
{
	int data=0;
	if(NULL != star)
	{
		if(*star == '-') 
		{
			star++;
			for(;*star!=',';star++)//-1100
			{
					data=data*10+((*star-'0'));	//①0*10+1 1  ②1*10+1 11 ③11*10+0 110 ④110*10+0 1100 
			}
			data=data*-1;
		}
		else
		{
				for(;*star!=',';star++)//1100
				{
						data=data*10+((*star-'0'));	//①0*10+1 1  ②1*10+1 11 ③11*10+0 110 ④110*10+0 1100
				}
		}
	}
	return data;
}

CRC16检验 CRC16_XMODEM

/*******************************************************************************
 * CRC16检验
 ******************************************************************************/
const uint16_t polynom = 0x1021;
uint16_t Crc16_value=0;
uint16_t crc16bitbybit(uint8_t *ptr, uint16_t len)
{
 uint8_t i;
 uint16_t crc = 0xffff;
 
 if (len == 0) {
  len = 1;
 }
 while (len--) {
  crc ^= *ptr;
  for (i = 0; i<8; i++)
  {
   if (crc & 1) {
    crc >>= 1;
    crc ^= polynom;
   }
   else {
    crc >>= 1;
   }
  }
  ptr++;
 }
 return(crc);
}

unsigned short CRC16_XMODEM(unsigned char *puchMsg, unsigned int usDataLen)

{

unsigned short wCRCin = 0x0000;

unsigned short wCPoly = 0x1021;

unsigned char wChar = 0;
int i = 0;
while (usDataLen--)

{

wChar = *(puchMsg++);

wCRCin ^= (wChar << 8);

for( i = 0;i < 8;i++)

{

if(wCRCin & 0x8000)

wCRCin = (wCRCin << 1) ^ wCPoly;

else

wCRCin = wCRCin << 1;

}

}

return (wCRCin) ;

}

十六进制数转十进制数

/**
  * @简介：十六进制数转十进制数         
  * @参数：   
  * @返回值：无
  */
long hexToDec(char *source)
{
    long sum = 0;
    long t = 1;
    int i, len;
 
    len = strlen(source);
    //len = 2;
	for(i=len-1; i>=0; i--)
    {
        sum += t * getIndexOfSigns(*(source + i));
        t *= 16;
    }  
 
    return sum;
}

返回ch字符在sign数组中的序号

/**
  * @简介：返回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;
}

整型转字符串。

/**
  * @简介：整型转字符串。              
  * @参数：   
  * @返回值：无
  */
void IntToStr(uint8_t* str, int32_t intnum)
{
    uint32_t i, Div = 1000000000, j = 0, Status = 0;
    
    if(intnum < 0)
    {
        intnum = intnum*(-1);
        str[j++] = '-';
    }
    
    for (i = 0; i < 10; i++)
    {
        str[j++] = (intnum / Div) + 48; /* '0' */
        
        intnum = intnum % Div;
        Div /= 10;
        if ((str[j-1] == '0') & (Status == 0))
        {
            j = 0;
        }
        else
        {
            Status++;
        }
    }
}

连接两个字符串。

/**
  * @简介：连接两个字符串。              
  * @参数：   
  * @返回值：无
  */
uint8_t *StringConcat2(uint8_t *str, const uint8_t *string)
{
    uint8_t *s = str;
    
    while(*s)
    {
        s++;
    }
    
    while(*string)
    {
        *s++ = *string++;
    }
    
    return str;        
}

接两个字符串并在最后加上回车。

/**
  * @简介：连接两个字符串并在最后加上回车。              
  * @参数：   
  * @返回值：无
  */
uint8_t *StringConcat(uint8_t *str, const uint8_t *string)
{
    uint8_t *s = str;
    
    while(*s)
    {
        s++;
    }
    
    while(*string)
    {
        *s++ = *string++;
    }
    
    *s++ = '\r';
    *s++ = '\n';
    *s = '\0';
    
    return str;     
}