Binary and hex for hardware

A bit is the smallest piece of information there is: a 0 or a 1. In a chip, it is one tiny switch that is either off or on. Eight bits in a row make a byte. Four bits make a nibble, half a byte.

A row of bits can stand for a whole number. This is binary, counting in twos. Each position has a number and a weight. Start at the right. The rightmost bit is bit 0, worth 1. Bit 1 is worth 2. Bit 2 is worth 4. Each step left doubles the weight: 8, 16, 32, 64, 128. To read the number, add up the weights of the bits that are 1.

Try 1010 0101. The 1s sit at bits 7, 5, 2 and 0. Their weights are 128, 32, 4 and 1. Add them: 128 + 32 + 4 + 1 = 165. The space in the middle is only there to make it easier to read. A number read this way can never be negative, so tools call it unsigned: it has no minus sign.

Two handy facts come out of this. First, every extra bit doubles how many patterns you can make. Eight bits make 256 patterns, which stand for the numbers 0 to 255. Sixteen bits make 65 536. Second, a row with only one bit switched on is worth exactly that bit's weight. Only bit 5 on is 32. Datasheets use that trick to point at a single switch. In code, a binary number starts with 0b, as in 0b10100101.

Hardware values are written in two number systems: binary, base 2, built in this part, and hexadecimal (hex), a base-16 shorthand for binary, built in the next. A bit is a single binary digit: 0 or 1. In hardware it is one on/off cell, or one wire that is either low or high. A byte is 8 bits, and a nibble is 4.

Binary writes a whole number in base 2. Bits are numbered from bit 0 at the right; bit n has weight 2^n. The value is the sum of the weights of the bits that are 1. For 1010 0101: 128 + 32 + 4 + 1 = 165. Bit 0 is called the least significant bit, and the highest-numbered bit the most significant bit. A whole number read this way, with no minus sign possible, is called unsigned.

Two counts follow. With n bits there are 2^n different patterns, so an 8-bit value has 256 patterns, read as the numbers 0 to 255. Each extra bit doubles the count: 16 bits give 65 536 patterns, 0 to 65 535. And a value with only bit n set equals 2^n: only bit 5 set is 32. That single-bit value is how datasheets and code name one bit.

Spaces between groups of four are for the reader only; 10100101 and 1010 0101 are the same number. In C++ source code a binary value is written with a 0b prefix, 0b10100101.

Long rows of 1s and 0s are hard to read and easy to copy wrong. So programmers use hexadecimal, or hex. Hex counts in sixteens. Its big trick is simple: one hex digit stands for exactly four bits, one nibble.

Counting in sixteens needs sixteen digits. Hex uses 0 to 9, then letters: A means 10, B means 11, C means 12, D means 13, E means 14, and F means 15. A hex number starts with 0x, so you can tell it apart from an ordinary number. 0xA5 is hex.

To turn binary into hex, chop the bits into groups of four, starting from the right. Swap each group for its hex digit. 1010 is 8 + 2 = 10, which is A. 0101 is 4 + 1 = 5. So 1010 0101 is 0xA5. To go back, write each hex digit as four bits. 0x3C becomes 0011 (3) and 1100 (12, or C): 0011 1100. You never have to do sums on the whole number.

Two hex digits make one byte, so a byte runs from 0x00 to 0xFF, which is 0 to 255. Both boards in this course have 32-bit processors. Many of their registers hold 32 bits, which is eight hex digits, like 0x40000000.

You can still turn hex into an ordinary number. Each place is worth 16 times the place to its right. So 0xA5 is 10 sixteens plus 5, which is 165. Most of the time, though, you want the bits, not the decimal.

Long binary numbers are hard to read and easy to miscopy. Hexadecimal (hex) is base 16, and its point is that one hex digit stands for exactly one nibble. It needs sixteen digit symbols: 0–9, then A = 10, B = 11, C = 12, D = 13, E = 14, F = 15. A hex value is written with a 0x prefix, in code and in datasheets: 0xA5.

Binary to hex: split the bits into groups of four from bit 0, and replace each group with its digit. 1010 0101 → A 5 → 0xA5. Hex to binary: expand each digit to four bits. 0x3C → 0011 1100. No arithmetic on the whole number is needed, which is why hex is used for bit patterns rather than decimal.

Two hex digits are one byte, so 0x00 to 0xFF covers 0 to 255. Both of this course's boards are built on 32-bit processors, and many of their registers are 32 bits wide: eight hex digits, such as 0x4000_0000 (the underscore, like the space in binary, is only for reading; C++ code writes it 0x40000000).

To get a decimal value from hex, multiply each digit by its place value, which goes up by 16 each step left: \texttt{0xA5} = 10 \times 16 + 5 = 165. In practice, convert the bits, not the decimal, because registers are read bit by bit.

A register is a tiny row of switches inside the microcontroller, usually 8, 16 or 32 bits long. Each one has an address, a number the chip uses to find it, like a house number. And every bit in it has a job written down in the datasheet.

Some registers hold data. Many are control registers. Writing a pattern of 1s and 0s into one turns a piece of hardware on, picks a mode, or sets a speed. Others are status registers. Reading one tells you what the hardware is doing, one bit per fact.

The datasheet splits each register into fields. A field is one bit, or a few bits side by side, with a name. Look at the invented register in the picture. Bit 7 is called ENABLE. Bits 6, 5 and 4 together are MODE. Bits 1 and 0 are SPEED. Write 0xB2 into it, which is 1011 0010. That one number sets ENABLE to 1, MODE to 011, and SPEED to 10, all at once. The datasheet then tells you what each pattern means.

Some bits are marked "reserved" or unused. The chip may need them left as they are. So good code changes only the field it wants and leaves the rest alone. Arduino's ready-made commands, such as digitalWrite(), do that for you behind the scenes. Chapter 13 shows you how to do it by hand.

A register is a small, fixed-width storage location inside the microcontroller, usually 8, 16 or 32 bits wide, with an address (a number that identifies it) and a documented meaning for every bit. Some registers hold data. Many are control registers: writing a pattern into one switches hardware on, picks a mode, or sets a speed. Others are status registers: reading one tells you, bit by bit, what the hardware is doing.

A datasheet describes each register as a table of fields: a single bit, or a run of neighbouring bits, with a name. In the invented register in the figure, ENABLE is bit 7, MODE is bits 6 to 4, and SPEED is bits 1 and 0. Writing 0xB2 (1011 0010) sets ENABLE to 1, MODE to 011 and SPEED to 10. The datasheet then says what MODE 011 means.

Bits a datasheet marks reserved or unused may have to keep a set value, so code changes only the field it means to change and leaves the others alone. Arduino functions such as digitalWrite() do exactly that on your behalf; Chapter 13 writes to the registers directly.