解释数据表中的十六进制并使用C位左移运算符进行转换

Question

I'm reading a datasheet and it says that the size of the image can be determined by this:

Image Length = len 0 + Len 1 * 100h + Len 2 * 10000h

And then the code implementing this on an mcu is

L0 = Buffer[5];
L1 = Buffer[6];
L2 = Buffer[7];

image_size = L0 + (L1 << 8) + (L2 << 16);

I was wondering if somebody could explain what is happening here? How do you go from one to the other? The mcu is 32-bit if that is relevant.

Answer 1

100h means 100 in hexadecimal notation which is 256 in decimal.

A multiplication of a number by 256 is equivalent of shifting its binary representation by 8 to the left.

Or more generally: the multiplication of a number by 2^n is equivalent of shifting its binary representation by n to the left. And a division of a number by 2^n is equivalent of shifting its binary representation by n to the right.

Example:

        2  * 256 = 512
000000010 <<   8 = 100000000    // << is the shift left operator

So actually this:

image_size = L0 + (L1 << 8) + (L2 << 16);

can be written as:

image_size = L0 + (L1 * 0x100) + (L2 * 0x10000);

The 0x prefix means that the number is given in hexadecimal notation instead of decimal notation, so we can also write:

image_size = L0 + (L1 * 256) + (L2 * 65536);

Answer 2

Think of your L0 , L1 , and L2 as two-digit hexadecimal numbers XX , YY , and ZZ .

The situation here is that they're being put together to compose the six-digit hexadecimal number:

0xZZYYXX

So one way of putting them together, using only bitwise operators, would be (L2 << 16) | (L1 << 8) | L0 (L2 << 16) | (L1 << 8) | L0 (L2 << 16) | (L1 << 8) | L0 , which we can visualize like this:

L0    ZZ         =    000000XX
L1    YY << 8    =    0000YY00
L2    ZZ << 16   =    00ZZ0000
                      --------
       bitwise OR:  0x00ZZYYXX

But as Michael Walz has explained, shifting left by 1 bit is equivalent to multiplying by 2, and shifting left by 8 bits is equivalent to multiplying by 256, or 0x100. Furthermore, bitwise OR is very close to addition, and as long as there's no overflow, bitwise OR pretty much is addition. So we get the same result as

(L2 * 0x10000) + (L1 * 0x100) + L0

If you're still having trouble seeing this, think about base 10 instead of base 16. Suppose I wanted to "put together" the numbers 12, 34, and 56 to get 123456. I'd do that by writing

(12 * 10000) + (34 * 100) + 56

Notice how the multipliers 10000 and 100 I used are eerily similar to 0x10000 and 0x100 in the hexadecimal example?

(Another way of thinking about these examples is that when you put L0 , L1 , and L2 together you were working with a three-digit number in base 256, and when I put 12, 34, and 56 together I was working in base 100. But if you're not ready to think about base 100 and base 256 yet, don't worry, you don't have to.)