嵌入式开发工具代码

将字符串中的小写字母转换为大写

//str:要转换的字符串
//len：字符串长度
void LowerToCap(u8 *str,u8 len)
{
	u8 i;
	for(i=0;i<len;i++)
	{
		if((96<str[i])&&(str[i]<123))	//小写字母
		str[i]=str[i]-32;				//转换为大写
	}
}

循环队列（Circular Buffer）

//循环队列是一种高效的数据结构，适用于缓冲区和数据流应用，例如串口通信接收缓冲
typedef struct 
{
    int buffer[SIZE];
    int head;
    int tail;
    int count;
} CircularBuffer;

void push(CircularBuffer *cb, int data) 
{
    if (cb->count < SIZE) 
    {
        cb->buffer[cb->head] = data;
        cb->head = (cb->head + 1) % SIZE;
        cb->count++;
    }
}

int pop(CircularBuffer *cb) 
{
    if (cb->count > 0) 
    {
        int data = cb->buffer[cb->tail];
        cb->tail = (cb->tail + 1) % SIZE;
        cb->count--;
        return data;
    }
    return -1; // Buffer is empty
}

断言（Assertion）

//断言用于在程序中检查特定条件是否满足，如果条件为假，会触发断言失败，并输出相关信息
#define assert(expression) ((void)0)
#ifndef NDEBUG
#undef assert
#define assert(expression) ((expression) ? (void)0 : assert_failed(__FILE__, __LINE__))
#endif

void assert_failed(const char *file, int line) 
{
    printf("Assertion failed at %s:%d\n", file, line);
    // Additional error handling or logging can be added here
}

位域反转（Bit Reversal）

//该函数将给定的无符号整数的位进行反转，可以用于某些嵌入式系统中的位级操作需求
unsigned int reverse_bits(unsigned int num) 
{
    unsigned int numOfBits = sizeof(num) * 8;
    unsigned int reverseNum = 0;

    for (unsigned int i = 0; i < numOfBits; i++) 
    {
        if (num & (1 << i)) 
        {
            reverseNum |= (1 << ((numOfBits - 1) - i));
        }
    }
    return reverseNum;
}

固定点数运算（Fixed-Point Arithmetic）

//在某些嵌入式系统中，浮点运算会较慢或不被支持。因此，使用固定点数运算可以提供一种有效的浮点数近似解决方案
typedef int16_t fixed_t;

#define FIXED_SHIFT 8
#define FLOAT_TO_FIXED(f) ((fixed_t)((f) * (1 << FIXED_SHIFT)))
#define FIXED_TO_FLOAT(f) ((float)(f) / (1 << FIXED_SHIFT))

fixed_t fixed_multiply(fixed_t a, fixed_t b) 
{
    return (fixed_t)(((int32_t)a * (int32_t)b) >> FIXED_SHIFT);
}

字节序转换（Endianness Conversion）

//用于在大端（Big-Endian）和小端（Little-Endian）字节序之间进行转换的函数
uint16_t swap_bytes(uint16_t value) { return (value >> 8) | (value << 8); }

位掩码（Bit Masks）

//用于创建一个只有指定位被置位的位掩码，可用于位操作
#define BIT_MASK(bit) (1 << (bit))

二分查找法（Binary Search）

//用于在已排序的数组中执行二进制查找的函数
int binary_search(int arr[], int size, int target) {
    int left = 0, right = size - 1;

    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1; // Not found
}

将数字转为字符串

// 将数字转为字符串
void numToString(u16 value)
{
	char strValue[8] = {0};
	int k = 0, j = 0;
	int num = (int)value;
	char tem[10];
	if (value == 0)
	{
		strValue[0] = '0';
		strValue[1] = '\0';
		return;
	}
	while (num)
	{
		tem[k++] = num % 10 + '0'; //将数字加字符0就变成相应字符
		num /= 10;				   //此时的字符串为逆序
	}
	tem[k] = '\0';
	k = k - 1;
	while (k >= 0)
	{
		strValue[j++] = tem[k--]; //将逆序的字符串转为正序
	}
	strValue[j] = '\0'; //字符串结束标志
}

BCD转ASC

void bcd2asc(uint8_t * bcd, uint8_t * asc, uint32_t len)
{
    uint32_t i,j;
    int8_t data;
    for(i=0,j=0; i<len; i++,j++)
    {
        data = bcd[i] >> 4;
        if(data>=0 && data<=9)
        	asc[j] = (uint8_t)(data + '0');
        if(data>=0xa && data<=0xf)
        	asc[j] = (uint8_t)(data + 'A' - 0xa);
        j++;
        data = (uint8_t)(bcd[i] & 0xf);
        if(data>=0 && data<=9)
        	asc[j] = (uint8_t)(data + '0');
        if(data>=0xa && data<=0xf)
        	asc[j] = (uint8_t)(data + 'A' - 0xa);
    }
}

ASC转BCD

void asc2bcd(uint8_t * str, uint8_t * bcd, uint32_t len)
{
    uint32_t i,j;
    for(i=0,j=0; i<len; i++,j++)
    {
        if(str[i] >= '0' && str[i]<='9')
            bcd[j] = (uint8_t)(str[i] - '0');
        if(str[i] >= 'a' && str[i]<='f')
            bcd[j] = (uint8_t)(str[i] - 'a' + 0xa);
        if(str[i] >= 'A' && str[i]<='F')
            bcd[j] = (uint8_t)(str[i] - 'A' + 0xa);

        bcd[j] <<= 4;
        i++;
        if(i>=len)
            return;

        if(str[i] >= '0' && str[i]<='9')
            bcd[j] |= str[i] - '0';
        if(str[i] >= 'a' && str[i]<='f')
            bcd[j] |= str[i] - 'a' + 0xa;
        if(str[i] >= 'A' && str[i]<='F')
            bcd[j] |= str[i] - 'A' + 0xa;
    }
}

hex转字符串

int Hex2Asc(uint8_t *pDst, uint8_t *pSrc, int SrcLen)
{
    const char tab[] = "0123456789ABCDEF";	// 0x0-0xf的字符查找表

    for (int i = 0; i < SrcLen; i++)
    {
        *pDst++ = tab[*((unsigned char*)pSrc) >> 4];		// 输出低4位
        *pDst++ = tab[*((unsigned char*)pSrc) & 0x0f];	// 输出高4位
        pSrc++;
    }

    // 输出字符串加个结束符
    *pDst = '\0';

    // 返回目标字符串长度
    return SrcLen * 2;
}

str2hex

int str2hex(char *str,char* hex,uint16_t hex_buffer_size)
{
	int i=0;
	int src_len = strlen(str);
	for ( i = 0; i < src_len; i += 2)
	{
		// ?????4λ
		if (*str >= '0' && *str <= '9')
		{
			*hex = (*str - '0') << 4;
		}
		else if (*str >= 'A' && *str <= 'F')
		{
			*hex = (*str - 'A' + 10) << 4;
		}
		else
		{
			*hex = (*str - 'a' + 10) << 4;
		}
		str++;
		// ?????4λ
		if (*str >= '0' && *str <= '9')
		{
			*hex |= *str - '0';
		}
		else if (*str >= 'A' && *str <= 'F')
		{
			*hex |= *str - 'A' + 10;
		}
		else
		{
			*hex |= *str - 'a' + 10;
		}
		str++;
		hex++;
	}

	return src_len / 2;
}

4个字节从左到右组成的无符号整数 转成十进制数字

int hex2int(unsigned char * data, unsigned int * dec)
{
    * dec = data[0] * 256*256*256;
    * dec += data[1] * 256*256;
    * dec += data[2] * 256;
    * dec += data[3];
    return 0;
}

bytes2uint

uint32_t bytes2uint(uint8_t *buf, uint16_t buffsize)
{
	uint32_t  x =0;
	uint32_t  i=0;
	for(i=0;i<buffsize;i++)
	{
	  	x = (x<<8)+buf[i];
	}
	return x;
}

无符号整数 转成 4个字节小端

int int2hex(unsigned int * dec, unsigned char * data)
{
    data[0] = (uint8_t) (* dec >> 24);
    data[1] = (uint8_t) (* dec >> 16);
    data[2] = (uint8_t) (* dec >> 8);
    data[3] = (uint8_t) (* dec >> 0);
    return 0;
}

uint2bytes

uint8_t*  uint2bytes(uint32_t i,uint8_t *buf)
{
    buf[0]=(i>>24)&0xff;
    buf[1]=(i>>16)&0xff;
    buf[2]=(i>>8)&0xff;
    buf[3]=i&0xff;
    return buf;
}

32位整形转成对应十进制数字的BCD

int int2bcd(unsigned int dec, unsigned char *bcd, int length)
{
    int i,temp;
    for(i=length-1; i>=0; i--)
    {
        temp=dec%100;
        bcd[i]=(unsigned char)(((temp/10<<4))+((temp%10)&0x0f));
        dec/=100;
    }
    return 0;
}

十进制数字的BCD转成对应32位整形

uint32_t bcd2int(unsigned char *bcd, int length)
{
    int i,temp,j;
    uint32_t dec=0,rslt=1;
    for(i=0; i<length; i++)
    {
        temp=((bcd[i]>>4)&0x0f)*10+(bcd[i]&0x0f);
        for(j=0; j<length-i-1; j++)
        {
            rslt*=100;
        }
        dec+=temp*rslt;
        rslt=1;
    }
    return dec;
}

字符转整形

int CharToInt(char hex)
{
    if (hex>='0' && hex <='9')
        return hex - '0';
    if (hex>='A' && hex <= 'F')
        return hex-'A'+10;
    if(hex>='a' && hex <= 'f')
        return hex-'a'+10;
    return -1;
}

BcdTimeToUTC

time_t BcdTimeToUTC(uint8_t bcd[])
{
	uint32_t tmp;
	struct tm st_time = {0};
	time_t time_utc;

	tmp = (bcd[0] >> 4) * 1000 + (bcd[0] & 0xf) * 100 + (bcd[1] >> 4) * 10 + (bcd[1] & 0xf);
	if (tmp < 1970)
	{
		return 0;
	}
	st_time.tm_year = tmp - 1900;

	tmp = (bcd[2] >> 4) * 10 + (bcd[2] & 0xf);
	st_time.tm_mon = tmp - 1;

	st_time.tm_mday = (bcd[3] >> 4) * 10 + (bcd[3] & 0xf);

	st_time.tm_hour = (bcd[4] >> 4) * 10 + (bcd[4] & 0xf);

	st_time.tm_min = (bcd[5] >> 4) * 10 + (bcd[5] & 0xf);

	st_time.tm_sec = (bcd[6] >> 4) * 10 + (bcd[6] & 0xf);

	time_utc = mktime(&st_time);

	return time_utc;
}

time2bcd

int time2bcd(struct tm * time, uint8_t * data)
{
	time->tm_mon++;
	time->tm_year += 1900;
	data[0] = (uint8_t)((time->tm_year/1000) << 4);
	data[0] |= (time->tm_year/100%10);
	data[1] = (uint8_t)((time->tm_year/10%10) << 4);
	data[1] |= (time->tm_year%10);
	data[2] = (uint8_t)((time->tm_mon/10%10) << 4);
	data[2] |= (time->tm_mon%10);
	data[3] = (uint8_t)((time->tm_mday/10%10) << 4);
	data[3] |= (time->tm_mday%10);
	data[4] = (uint8_t)((time->tm_hour/10%10) << 4);
	data[4] |= (time->tm_hour%10);
	data[5] = (uint8_t)((time->tm_min/10%10) << 4);
	data[5] |= (time->tm_min%10);
	data[6] = (uint8_t)((time->tm_sec/10%10) << 4);
	data[6] |= (time->tm_sec%10);
	return 0;
}

uint2decstr

char*  uint2decstr(uint32_t x,char *buf)
{
	const char tab[] = "0123456789ABCDEF";
	uint32_t y=0;
	char tempbuf[14]={0};
	int  i =12;

	do{
		 tempbuf[i]=tab[x%10];
		 x=x/10;
		 i--;
	}
	while(x!=0);
	memcpy(buf,tempbuf+i+1,14-i);
	return buf;
}

uint2hexstr

char*  uint2hexstr(uint32_t x,char *buf)
{
	const char tab[] = "0123456789ABCDEF";
	uint32_t y=0;
	char tempbuf[14]={0};
	int  i =12;
	do{
		 tempbuf[i]=tab[x&0x0f];
		 x=x>>4;
		 i--;
	}
	while(x!=0);
	memcpy(buf,tempbuf+i+1,14-i);
	return buf;
}

bcd2uint

uint32_t  bcd2uint(uint8_t *bcdbuf, uint16_t bufsize)
{
   uint32_t  x=0;
   for(int i=0;i<bufsize;i++)
   {
	  x*=10;
	  x+=((bcdbuf[i]>>4)&0x0f);
	  x*=10;
      x+=(bcdbuf[i]&0x0f);
   }
   return x;
}

uint2bcd

 uint32_t  uint2bcd(uint32_t x,uint8_t *bcdbuf,uint16_t bufsize)
{
   uint32_t y=0;
   char     tempbuf[14]={0};
   int  i =12;

   do{
      tempbuf[i]=x%10;
      x=x/10;
      if(x!=0)
      {
    	tempbuf[i]|=(x%10)<<4;
    	x=x/10;
      }
      i--;
   }
   while(x!=0);
   memcpy(bcdbuf,tempbuf+i+1,13-i-1);
   return (13-i-1);
}

U8ToU16

 uint16_t U8ToU16(uint8_t high, uint8_t low)
{
	return (high << 8) + low;
}

U16ToU8

uint8_t* U16ToU8(uint16_t x, uint8_t* buf)
{
	buf[0] = (x >> 8) & 0xff;
	buf[1] = x  & 0xff;

	return buf;
}