如何设置特定位？

Question

Let's say I've got a uint16_t variable where I must set specific bits.

Example:

uint16_t field = 0;

That would mean the bits are all zero: 0000 0000 0000 0000

Now I get some values that I need to set at specific positions.

val1=1; val2=2, val3=0, val4=4, val5=0;

The structure how to set the bits is the following

0|000|  0000| 0000 000|0

val1 should be set at the first bit on the left. so its only one or zero.

val2 should be set at the next three bits. val3 on the next four bits. val4 on the next seven bits and val5 one the last bit.

The result would be this: 1010 0000 0000 1000

I only found out how to the one specific bit but not 'groups'. (shift or bitset)

Does anyone have an idea how to solve this issue?

Answer 1

There are (at least) two basic approaches. One would be to create a struct with some bitfields:

struct bits { 
    unsigned a : 1;
    unsigned b : 7;
    unsigned c : 4;
    unsigned d : 3;
    unsigned e : 1;
};

bits b;

b.a = val1;
b.b = val2;
b.c = val3;
b.d = val4;
b.e = val5;

To get the 16-bit value, you could (for one example) create a union of that struct with a uint16_t . Just one minor problem: the standard doesn't guarantee what order the bit fields will end up in when you look at the 16-bit value. Just for example, you might need to reverse the order I've given above to get the order from most to least significant bits that you really want (but changing compilers might muck things up again).

The other obvious possibility would be to use shifting and masking to put the pieces together into a number:

int16_t result = val1 | (val2 << 1) | (val3 << 8) | (val4 << 12) | (val5 << 15);

For the moment, I've assumed each of the inputs starts out in the correct range (ie, has a value that can be represented in the chosen number of bits). If there's a possibility that could be wrong, you'd want to mask it to the correct number of bits first. The usual way to do that is something like:

uint16_t result = input & ((1 << num_bits) - 1);

In case you're curious about the math there, it works like this. Lets's assume we want to ensure an input fits in 4 bits. Shifting 1 left 4 bits produces 00010000 (in binary). Subtracting one from that then clears the one bit that's set, and sets all the less significant bits than that, giving 00001111 for our example. That gives us the first least significant bits set. When we do a bit-wise AND between that and the input, any higher bits that were set in the input are cleared in the result.

Answer 2

One of the solutions would be to set a K-bit value starting at the N-th bit of field as:

uint16_t value_mask = ((1<<K)-1) << N; // for K=4 and N=3 will be 00..01111000
field = field & ~value_mask; // zeroing according bits inside the field
field = field | ((value << N) & value_mask); // AND with value_mask is for extra safety

Or, if you can use struct instead of uint16_t, you can use Bit fields and let the compiler to perform all these actions for you.

Answer 3

finalvle = 0;
finalvle = (val1&0x01)<<15;
finalvle += (val2&0x07)<<12;
finalvle += (val3&0x0f)<<8
finalvle += (val4&0xfe)<<1;
finalvle += (val5&0x01);

Answer 4

You can use the bitwise or and shift operators to achieve this.

Use shift << to 'move bytes to the left':

int i = 1;  // ...0001
int j = i << 3 // ...1000

You can then use bitwise or | to put it at the right place, (assuming you have all zeros at the bits you are trying to overwrite).

int k = 0;  // ...0000
k |= i // ...0001
k |= j // ...1001

Edit: Note that @Inspired's answer also explains with zeroing out a certain area of bits. It overall explains how you would go about implementing it properly.

Answer 5

try this code:

uint16_t shift(uint16_t num, int shift)
{
    return num | (int)pow (2, shift);
}

where shift is position of bit that you wanna set