Question

I’m reading two registers from microcontroller. One have 4-bit MSB (First 4-bits has some other things) and another 8-bit LSB. I want to convert it into one 12-bit uint (16 bit to be precise). So far I made it like that:

UINT16 x;
UINT8 RegValue = 0;
UINT8 RegValue1 = 0;

ReadRegister(Register01, &RegValue1);
ReadRegister(Register02, &RegValue2);

x = RegValue1 & 0x000F;
x  = x << 8;
x = x | RegValue2 & 0x00FF;

is there any better way to do that?

/* To be more precise ReadRegister is I2C communication to another ADC. Register01 and Register02 are different addresses. RegValue1 is 8 bit but only 4 LSB are needed and concatenate to RegValue (4-LSB of RegValue1 and all 8-bits of RegValue). */

Answer 1

The RegValue & 0x00FF mask is unnecessary since RegValue is already 8 bit.

Breaking it down into three statements may be good for clarity, but this expression is probably simple enough to implement in one statement:

x = ((RegValue1 & 0x0Fu) << 8u) | RegValue ;

The use of an unsigned literal (0x0Fu) makes little difference but emphasises that we are dealing with unsigned 8-bit data. It is in fact an unsigned int even with only two digits, but again this emphasises to the reader perhaps that we are only dealing with 8 bits, and is purely stylistic rather than semantic. In C there is no 8-bit literal constant type (though in C++ '\x0f' has type char). You can force better type agreement as follows:

#define LS4BITMASK ((UINT8)0x0fu)

x = ((RegValue1 & LS4BITMASK) << 8u) | RegValue ;

The macro merely avoids repetition and clutter in the expression.

None of the above is necessarily “better” than your original code in terms of performance or actual generated code, and is largely a matter of preference or local coding standards or practices.