嵌入式工具函数-数据合并拆分

在嵌入式编程中，通常涉及到不同类型变量的合并和拆分，例如将u32、u16、u3的三个变量组成一帧数据，当然可以在封帧的时候移位填充，然后在解帧的时候按顺序合并回来，但坏处是代码难看，并且每次都得注意一下高地位。对于这类常用的功能，写该工具函数。

1 应用举例

拆分

例如，封装三种类型的变量

uint32_t  data_1;
uint16_t data_2;
uint8_t data_3;
//用指针指向数据帧保存的buffer
uint8_t *pBuf = payload;
//拆分32位数据，并将其存放buffer中，指针偏移
pBuf = Util_bufferUint32(pBuf, data_1);//短地址
//拆分32位数据
pBuf = Util_bufferUint16(pBuf, data_2);//电压
//8位就直接塞进去了
*pBuf++ = ata_3;

其中函数:

uint8_t *Util_bufferUint32(uint8_t *pBuf, uint32_t val)

将val按照地位在前高位在后的原则拆分成4个8位数据，顺序存入pBuf，并且指针移动4字节

---

合并

拆帧取出数据:

uint32_t  data_1;
uint16_t data_2;
uint8_t data_3;

uint8_t *pBuf = payload;
data_1=Util_parseUint32(pBuf);
pBuf+=4;
data_1=Util_parseUint16(pBuf);
pBuf+=2;
data_1 = *pBuf;

其中函数：

uint32_t  Util_parseUint32(uint8_t *pArray)

将pArray开始的连续4个字节合并成一个32位字节返回，不会修改指针指向。

工具函数API

//拼接该指针的首位和次位数据，首位是16位的低位
uint16_t Util_parseUint16(uint8_t *pArray);
//拆分16位数据存入pBuf
uint8_t *Util_bufferUint16(uint8_t *pBuf, uint16_t val);
//将32位数据拆分保存在数组中
uint8_t *Util_bufferUint32(uint8_t *pBuf, uint32_t val);
//从数组中取出4位合并成32位
uint32_t Util_parseUint32(uint8_t *pArray);

uint32_t Util_buildUint32(uint8_t byte0, uint8_t byte1, uint8_t byte2,uint8_t byte3);
//拆分32位数据，获取某一个8位的数据
uint8_t Util_breakUint32(uint32_t var, int byteNum);
//将两个8位组成一个十六位
uint16_t Util_buildUint16(uint8_t loByte, uint8_t hiByte);

函数实现

/*!
 Get the high byte of a uint16_t variable
 获取16位数据的高位
 */
uint8_t Util_hiUint16(uint16_t a)
{
    return((a >> 8) & 0xFF);
}

/*!
 Get the low byte of a uint16_t variable
 获取16位数据的地位
 */
uint8_t Util_loUint16(uint16_t a)
{
    return((a) & 0xFF);
}

/*
拆分16位数据，存入buffer
pBuf :数据指针
val  :拼接后返回值
return :如果传入的是一串数据，则返回使用后指针新的指向
*/

uint8_t *Util_bufferUint16(uint8_t *pBuf, uint16_t val)
{
    *pBuf++ = Util_loUint16(val);
    *pBuf++ = Util_hiUint16(val);
    return(pBuf);
}

//将两个8位组成一个十六位
//loByte :16位地位数据
//hiByte :16位高位数据
//return :拼接后数据
uint16_t Util_buildUint16(uint8_t loByte, uint8_t hiByte)
{
    return((uint16_t)(((loByte) & 0x00FF) + (((hiByte) & 0x00FF) << 8)));
}

//拼接该指针的首位和次位数据，首位是16位的低位
uint16_t Util_parseUint16(uint8_t *pArray)
{
    return(Util_buildUint16(pArray[0], pArray[1]));
}

//拆分32位数据，获取某一个8位的数据
//var :原数据
//byteNum :拆分哪一个8位数据(0,1,2,3)
//return :返回所选择位的数据
uint8_t Util_breakUint32(uint32_t var, int byteNum)
{
    return(uint8_t)((uint32_t)(((var) >> ((byteNum) * 8)) & 0x00FF));
}

//将32位数据拆分保存在数组中
//pBuf :被保存数据的位置指针
//val :被拆分的32位数据
//return :数据依次保存后剩余空间的指针
uint8_t *Util_bufferUint32(uint8_t *pBuf, uint32_t val)
{
    *pBuf++ = Util_breakUint32(val, 0);
    *pBuf++ = Util_breakUint32(val, 1);
    *pBuf++ = Util_breakUint32(val, 2);
    *pBuf++ = Util_breakUint32(val, 3);
    return(pBuf);
}

//合并成32位数据
//byte :0~7
//byte :8~15
//byte :16~23
//byte :24~31
uint32_t Util_buildUint32(uint8_t byte0, uint8_t byte1, uint8_t byte2,
                            uint8_t byte3)
{
    return((uint32_t)((uint32_t)((byte0) & 0x00FF) +
                     ((uint32_t)((byte1) & 0x00FF) << 8) +
                     ((uint32_t)((byte2) & 0x00FF) << 16) +
                     ((uint32_t)((byte3) & 0x00FF) << 24)));
}

//直接将pArray组成一个32位数据，首地址位最低位
uint32_t Util_parseUint32(uint8_t *pArray)
{
    return(Util_buildUint32(pArray[0], pArray[1], pArray[2], pArray[3]));
}