0301_APP/APP/string_fuc.c

/** ******************************************************************************
 * @file    String.c
 * @author  度云未来 DOIOT
 * @brief   针对公司模块AT指令的处理库
 ******************************************************************************
 * @attention
 * <h2><center>&copy; Copyright (c) 2019 成都度云未来
 * All rights reserved.</center></h2>
 * 注意:本程序针对cubemx 生成的hal库程序快速开发
 * 环境:keil5.0
 * STM32Cube FW_F1 V1.8.0
 * 文件版本：1.3		更新时间2020/10/15   降低了关联文件之间的耦合度
 ********************************************************************************/
#include "includes.h"    
#include "string_fuc.h"
#include "stdarg.h"
#include "string.h"
#include "stdio.h"
#include "stdlib.h" 

//#include "AT_Module.h"		 /*AT指令相关的头文件*/


/*--------------------------------裁剪功能[针对低容量设计,使能后会自动生成一个全局实例]----------------------------------------------*/

#define  config_String_process							1
#define  config_Array_process								1

/*--------------------------------[string字符串类的处理函数]----------------------------------------------

	尽管  char str[],uint8_t arry[]本质是一样的，但是本文件根据理解不同，来分成string字符串和arry数组
	
	如果	使用的是其字符串成分，就使用srr函数，如果使用其数据成分，就使用arry函数。


char str[]="32323232" ---> uint8_t arry={0x32,0x32,0x32,0x32};
【string 数据按16进制理解，两两转化成 8位数组 arry】
str_2_hex_arry;

char str[]="32323232" ---> uint8_t arry={32,32,32,32};
【string 数据按10进制理解，两两转化成 8位数组 arry】
str_2_dec_arry;

char "3" char "2" 		---> uint8_t  i=0x32;
【两个字符按十六进制理解组合成一个8位的十六进制变量】
 char_2_hex

char "3" char "2"  		--->  uint8_t  i=32;
【两个字符按十进制理解,组合成一个8位的十进制变量】
 char_2_dec

char str[]="stm32f103" --->   char str[]="73746D33326631"
【string 数据按ascii理解，单个单个的转化成十六进制表示的string】
AsciiStr_2_HexStr;

*----------------------------------[arry字符串类的处理函数]----------------------------------------------*/
/*

Arry

uint8_t arry={0x32,0x32,0x,32,0x32};  "32323232"
【8位数组每八位一组的转化成16进制表示的string】
arry_2_hexstr;




---------------------------------------------------------------------------------*/

/*string类的句柄*/
#if(config_String_process) 
 STR   Str;
#endif
#if(config_Array_process)
 Array array;
#endif
 
#if(config_String_process) 
/**@brief AsciiStr_2_HexStr :	string 按ascii理解，单个单个的转变成 hex 字符串
* @param  ascii_str		 : 字符串或数组,是数组的情况下需要保证有结束位
* @param  hex_str	 		 : 生成的新字符串
* 例子:		"stm32f103"   "73746D33326631"
*/
uint8_t AsciiStr_2_HexStr(char *ascii_str,char hex_str[])
{
			uint16_t i;
			char hex[3]={0};	
			memset(hex,0,3);
			for(i=0;i<strlen(ascii_str);i++)
			{
			sprintf(hex,"%02x",ascii_str[i]);
			strcat(hex_str,hex);		
			}
			return 1;
}



/**@brief str_2_dec_arry:【string 数据按10进制理解，两两转化成 8位数组 arry】
*  @param  ascii_str		 : 字符串或数组,导入后自身会被转化成hex的字符串
* return 会返回长度
* 例子:		char s[]="32323232" ---> uint8_t arry={32,32,32,32};
*/
uint16_t str_2_dec_arry(char ascii_str[],uint8_t dex_arry[])
{
			uint16_t len=strlen(ascii_str)*2;
			char hex_str[len+2];
			char hex[3]={0};	
			uint16_t i;
			uint16_t n;
			memset(hex_str,0,len);
	
			memset(hex,0,3);
			for(i=0;i<len/2;i++)
			{
				hex[0]=ascii_str[i*2];
				hex[1]=ascii_str[i*2+1];
				n=atoi(hex);
				dex_arry[i]=n;	
			}
			return i+1;
}

/**@brief str_2_hex_arry:【string 数据按10进制理解，两两转化成 8位数组 arry】
*  @param  ascii_str		 : 字符串或数组,导入后自身会被转化成hex的字符串
* return 会返回长度
* 例子:		char s[]="32323232" ---> uint8_t arry={0x32,0x32,0x32,0x32};
*/
uint16_t str_2_hex_arry(char ascii_str[],uint8_t hex_arry[])
{
			uint16_t len=strlen(ascii_str)*2;
			char hex[3]={0};	
			char hex_str[len+2];
			uint16_t i;
			uint16_t n;
			memset(hex_str,0,len);
	
			memset(hex,0,3);
			for(i=0;i<len/2;i++)
			{
				hex[0]=ascii_str[i*2];
				hex[1]=ascii_str[i*2+1];
				n=strtol(hex, NULL, 16);
				hex_arry[i]=n;	
			}
			return i+1;
}

/**@brief  char_2_hex:两个字符按16进制理解转换成一个十六进制，return返回
* 例子:		char c1='1'  char c2='1'  uint8_t a=11;
*/
uint8_t  char_2_hex(char c1,char c2)
{
			char hex[3]={0};
			uint16_t i;
			hex[0]=c1;
			hex[1]=c2;
			i = strtol(hex, NULL, 16);
			
			return i;
}
/**@brief  char_2_dec两个字符按10进制理解转换成一个十进制，return返回
* 例子:		char c1='1'  char c2='1'  uint8_t a=0x11;
*/
uint8_t  char_2_dec(char c1,char c2)
{
			char hex[3]={0};
			hex[0]=c1;
			hex[1]=c2;
			
			return atoi(hex);
}

/**@brief R_CUT:右靠裁剪len长至buff，str为原数据，之所以选择加一个buff是为了保护原数据
*/
uint8_t R_CUT(char *str,char buff[],uint8_t len)
{
		uint16_t length=strlen(str);
		if(length>=len)
		{
			strncpy(buff,str+(length-len),len);
			return 1;
		}
		

		return 0;	
}
/**@brief L_CUT:左靠裁剪len长至buff，str为原数据，之所以选择加一个buff是为了保护原数据
*/
uint8_t L_CUT(char *str,char buff[],uint8_t len)
{
		uint16_t length=strlen(str);
		if(length>=len)
		{
			strncpy(buff,str,len);
			return 1;
		}
		return 0;	
}



/**@brief AsciiStr_convert_HexStr:ascii字符数组转hex字符数组
* @param  ascii_str		 : 字符串或数组,导入后自身会被转化成hex的字符串
* 例子:		"stm32f103"  "73746D33326631"
*/
uint8_t AsciiStr_convert_HexStr(uint8_t ascii_str[])
{
			uint16_t len=strlen((char*)ascii_str);
			char hex_str[len*2+2];
			memset(hex_str,'\0',len*2+2);
			

	
			char hex[3]={0};	
			uint16_t i;
			for(i=0;i<len;i++)
			{
			sprintf(hex,"%02x",ascii_str[i]);
			strcat(hex_str,hex);		
			}
			strcpy((char*)ascii_str,hex_str);
			return 1;
}

/**@brief AsciiStr_convert_HexStr:ascii字符数组转hex字符数组
* @param  ascii_str		 : 字符串或数组,导入后自身会被转化成hex的字符串
* 例子:		"73746D33326631"    "stm32f103"  
*/
uint8_t HexStr_convert_AsciiStr(uint8_t ascii_str[])
{
			uint16_t len=strlen((char*)ascii_str);
			char hex_str[len/2+2];
			memset(hex_str,'\0',len/2+2);

			char hex[3]={0};	
			char ascii[2]={0};
			uint16_t i;
			int vlue=0;
			for(i=0;i<len;i+=2)
			{
			hex[0]=ascii_str[i];
			hex[1]=ascii_str[i+1];
			vlue= strtol(hex, NULL, 16);
			sprintf(ascii,"%c",vlue);
			strcat(hex_str,ascii);		
			}
			strcpy((char*)ascii_str,hex_str);
			return 1;
}


/**@brief str_2_dec_arry:【string 数据按10进制理解，两两转化成 8位数组 arry】
*  @param  ascii_str		 : 字符串或数组,导入后自身会被转化成hex的字符串
* return 会返回长度
* 例子:		char s[]="32323232" ---> uint8_t arry={32,32,32,32};
*/
uint16_t str_convert_dec_arry(uint8_t ascii_str[])
{
			uint8_t fifo[500];
			uint16_t len=strlen((char*)ascii_str)*2;
			char hex_str[len+2];
			memset(hex_str,0,len);
			
			
			char hex[3]={0};	
			memset(hex,0,3);
			uint16_t i;
			uint16_t n;
			for(i=0;i<len/2;i++)
			{
				hex[0]=ascii_str[i*2];
				hex[1]=ascii_str[i*2+1];
				n=atoi(hex);
				fifo[i]=n;	
			}
			memcpy(ascii_str,fifo,i);
			return i+1;
}

/**@brief str_2_hex_arry:【string 数据按10进制理解，两两转化成 8位数组 arry】
*  @param  ascii_str		 : 字符串或数组,导入后自身会被转化成hex的字符串
* return 会返回长度
* 例子:		char s[]="32323232" ---> uint8_t arry={0x32,0x32,0x32,0x32};
*/
uint16_t str_convert_hex_arry(uint8_t ascii_str[])
{
			uint8_t fifo[500];
			uint16_t len=strlen((char*)ascii_str)*2;
			char hex_str[len+2];
			memset(hex_str,0,len);
	
			char hex[3]={0};	
			memset(hex,0,3);
			uint16_t i;
			uint16_t n;
			for(i=0;i<len/2;i++)
			{
				hex[0]=ascii_str[i*2];
				hex[1]=ascii_str[i*2+1];
				n=strtol(hex, NULL, 16);
				fifo[i]=n;	
			}
			memcpy(ascii_str,fifo,i);
			return i+1;
}


/**@brief R_CUT:右靠裁剪len长至buff,直接改变原数据
*/
uint8_t Convert_R_CUT(char *str,uint8_t len)
{
		
		uint16_t length=strlen(str);
		char buff[length];
		
		if(length>=len)
		{
			strncpy(buff,str+(length-len),len);
			memset(str,0,length);
			strcpy(str,buff);
			return 1;
		}
		

		return 0;	
}
/**@brief L_CUT:左靠裁剪len长至buff，直接改变原数据
*/
uint8_t Convert_L_CUT(char *str,uint8_t len)
{
		uint16_t length=strlen(str);
		char buff[length];
		if(length>=len)
		{
			strncpy(buff,str,len);
			strcpy(str,buff);
			return 1;
		}
		return 0;	
}

/**@brief Shift_left:字符串左移,相当于裁剪左边的几位
*/
uint8_t Shift_left(char *str,uint8_t len)
{
	int lengtth=strlen(str);
	int i=0;
	for(i=0;i<(lengtth);i++)
	{
		*(str+i)=*(str+len+i);
		if(i>=(lengtth-len))*(str+i)=0; 
	}
	return 1;
}


#endif
/*----------------------------------------------------------------------------------*/
#if(config_Array_process)
/**@brief Arry_2_hexstr :	8位数组按数据理解转换成16进制表示的字符串
* @param  arry		 : 输入数组
* @param  hex_str 		 : 生成的字符串
	[注：导出数组外部需清0]
* 例子:	uint8_t arry={0x32,0x32,0x32,0x32}; ---> "32323232"
*/
uint8_t Arry_2_hexstr(uint8_t arry[],char hex_str[],uint16_t len)
{
			uint16_t i;
			char hex[3]={0};
			memset(hex_str,0,len*2);
			for(i=0;i<len;i++)
			{
			
			sprintf(hex,"%02x",arry[i]);
			strcat(hex_str,hex);		
			}
			
			return 1;
}
/**@brief Arry_2_decstr :	8位数组按数据理解转换成16进制表示的字符串
* @param  arry		 : 输入数组
* @param  hex_str 		 : 生成的字符串

* 例子:	uint8_t arry={0x32,0x32,0x32,0x32}; ---> "32323232"
*/
uint8_t Arry_2_decstr(uint8_t arry[],char dec_str[],uint16_t len)
{
			uint16_t i;
			char hex[3]={0};
			for(i=0;i<len;i++)
			{
			
			sprintf(hex,"%02d",arry[i]);
			strcat(dec_str,hex);		
			}
			return 1;
}

/**@brief Arry_2_decstr :	8位数组按数据理解转换成16进制表示的字符串
* @param  arry		 : 输入数组
* @param  hex_str 		 : 生成的字符串

* 例子:	uint8_t arry={0x32,0x32,0x32,0x32}; ---> "2222"
*/
uint8_t Arry_2_AsciiStr(uint8_t arry[],char dec_str[],uint16_t len)
{
			uint16_t i;
			char hex[3]={0};
			for(i=0;i<len;i++)
			{
			
			sprintf(hex,"%c",arry[i]);
			strcat(dec_str,hex);		
			}
			return 1;
}


/**@brief R_CUT:右靠裁剪len长至buff，str为原数据，之所以选择加一个buff是为了保护原数据
*/
uint8_t Arry_R_CUT(uint8_t arry[],uint8_t arry_len,uint8_t cut_len)
{
		
		uint8_t buff[512]={0};
		if(arry_len>=cut_len)
		{
			uint16_t i;
			for(i=cut_len;i<arry_len;i++)
			{
				buff[i]=arry[i];
			}
			memcpy(arry,buff,arry_len);
			return 1;
		}
		

		return 0;	
}
/**@brief L_CUT:左靠裁剪len长至buff，str为原数据，之所以选择加一个buff是为了保护原数据
*/
uint8_t Arry_L_CUT(uint8_t arry[],uint8_t arry_len,uint8_t len)
{
		
		if(arry_len>=len)
		{
			uint16_t i;
			for(i=len;i<arry_len;i++)
			{
				arry[i]=0;
			}
			return 1;
		}

		return 0;	
}
#endif

#if(config_String_process) 
void STR_init(STR * st)
{
	
	st->to.Hex_str=AsciiStr_2_HexStr;
		
	st->to.dec_arry=str_2_dec_arry;
	
	st->to.hex_arry=str_2_hex_arry;
	
	st->to.char_2_dec=char_2_dec;
	
	st->to.char_2_hex=char_2_hex;
	
	st->to.L_CUT=L_CUT;
	
	st->to.R_CUT=R_CUT;
	
	
	st->convert.Hex_Str=AsciiStr_convert_HexStr;
	
	st->convert.Ascii_Str= HexStr_convert_AsciiStr;
	
	st->convert.dec_arry=str_convert_dec_arry;
	
	st->convert.hex_arry=str_convert_hex_arry;
	
	st->convert.L_CUT=Convert_R_CUT;
	
	st->convert.R_CUT=Convert_R_CUT;

	st->convert.L_Shift=Shift_left;
}
#endif

#if(config_Array_process)
void Array_init(Array *ar)
{
	
	ar->hexStr=Arry_2_hexstr;
	
	ar->decStr=Arry_2_decstr;
	
	ar->R_CUT=Arry_R_CUT;
	
	ar->L_CUT=Arry_L_CUT;
	
	ar->asciiStr=Arry_2_AsciiStr;
}
#endif