microBuilder.eu

Understanding Hexadecimal Numbers

If you have no idea what a hexadecimal number is, you've probably used them but just don't know it. Have you ever tried to make a web page, and seen things like #FFFFFF (for white) or #FF0000 (for red) in a CSS file or in the HTML? Those are hexadecimal numbers representing a specific colour value (out of a possible 16,777,215 choices!), and are simply a much more concise and efficient way of communicating numeric information.  Don't worry if you don't know why #FF0000 is red, but #EFEFEF is really light gray ... we'll explain that below.

While hexadecimal numbers are rarely used by most C#, Java or VB developpers (and they are clearly in the majority), they are used everywhere when working with small embedded systems and microcontrollers, so it's pretty important that you understand what all those funny numbers and letters mean before you can do anything really fun. It's actually not all that complicated once you understand how the math works ... but there aren't a lot of easy to understand explanations out there, so we thought it was worth having a go at explaining it ourselves.

In the beginning was the Bit

Essentially, any microprocessor that you use -- from the humblest 8-bit chip right up to the latest 64-bit multi-core monster -- operates on the same straight-forward principle of 'bits'. Millions and billions of bits, all running around inside your circuits like a tired little army of ants. All a bit knows is whether it's a '1' or a '0', or more usefully whether it's on or off, true or false, enabled or disabled, etc. Bits are pretty boring by themselves, but all modern electronic devices have these simple-minded, hard-working 'bits' at their core, and without them your electric Hello Kitty Manicure Set and the machine that knits together your Power Rangers underwear just wouldn't be the same.  And what kind of world would that be?

And the Bit saw that it wasn't good to be alone

While our hard-working little bi-polar bits can be useful on their own, they're social creatures who work better in teams ("many hands makes light work", so they say).  Enter the binary numbering system -- the next logical step up the evolutionary ladder. Binary numbers are made by grouping a series of bits together together in a specific order, and by using a specific sequence of 1's and 0's you can make bigger numbers, like say '15' or '65'.  Now isn't that fun!  How it works is that you stick, say, 8 single-minded little bits together in a row, and mathematically, the number of possible combinations of 1's and 0's (say, 01011010) can be a value between 0 (00000000) and 255 (11111111).  If you really want to know all the nitty-gritty details on binary numbers, read up on the Binary numeral system.  Basically, though, it goes something like this:

And the Bits were fruitful and multiplied

While almost everyone has heard of binary numbers, not everyone properly understands the difference between 8-bit, 32-bit and 64-bit (or higher) processor architectures -- except, of course, that bigger is probably better (or at least that's what most of the spam in my mailbox seems to imply). The fundamental difference between these different architectures is directly related to bits and to binary numbering. We call an 8-bit chip '8-bit' because, internally, it uses 'numbers' or collections of bits that are eight 1's or 0's long. That means that we can naturally use values between 0 and 255. Anything larger than this involves more work for the processor as it actually has to get broken down into the individual 8-bit pieces that it knows how to deal with. The advantage offered by 32 and 64-bit processors is that they can naturally use significantly larger numbers without having to do any complicated or cycle-consuming acrobatics, making execution faster amongst other things.  You can see the difference between these three common 'bit' lengths below :

And the Bits realized that writing in 1's and 0's is 72-65-61-6C-6C-79-20-73-6C-6F-77

The problem with the binary number system is that it takes a lot of space to write out all those 1's and 0's, making them rather tedious to work with for anything bigger than 1 or 0, and binary numbers are rather prone to human-error since everything looks the same ... especially with huge 32-bit or 64-bit values!  One solution that was proposed to fix this was to take all those binary 1's and 0's and convert them into something more usable and concise, and ... dum dum dum ... the hexadecimal numbering system was born!  Somewhere some smart person realized that you could replace 4 bits (representing values between 0 and 15) with 1 number or letter between 0-9 and A-F, and communicate the same information using 1/4 the space.  Basically, hexadecimal is really just a visual compression engine to make things on the screen look smaller, even though the exact same information is being communicated beneath the surface.  The conversion works as follows:

You can see that it takes a lot less space to convey the same information in hexadecimal, and it's far less error prone to have a string of characters between 0-9 and A-F than it is a line of only 1's and 0's. But what if you want to deal with numbers larger than 15, you ask? You simply add another 4-bit hexadecimal character. For example, if you want to work with an 8-bit value between 0 and 255, rather than 8 1's and 0's you can simple use two hexadecimal characters side by side. For example, C6 is the hexadecimal equivalent of 1100 0110.

For better or for worse, a very large percentage of the 'numbers' that you will see and work with on any microprocessor are most likely to be presented in hexadecimal form, so you better get used to working with them. Essentially, all you really need to understand in most cases are 8-bit and 32-bit hexadecimal values, since those two account for 95% of the values you're likely to see or work with yourself. An 8-bit hexadecimal character is made up of two numbers or letters (ex.: C6).  Until the widespread adoption of Unicode in recent years, all text that was handled on your computer was based on 8-bit values, with, for example, the letter 'n' (lower case) being equal to '6E' in hexadecimal notation (or 110 in decimal) using ASCII encoding.

Recovering the 'Bits' in 32-bit hexadecimal values

If you're working with an 8-bit or a 32-bit processor, and you want to know what a large hexadecimal number really contains, all you need to convert each letter back into it's four bit parts is the conversion table above.  An 8-bit processor will use two letter codes (Two 4-bit characters = 8 bits) and a 32-bit processor will use eight letter code (Eight 4-bit characters = 32 bits). As an example, here is how you would convert a 32-bit hexadecimal to binary and back.

Useless Trivia

Can you understand now why, in a 24-bit RGB colour scheme, #FF0000 is equal to red, and #EFEFEF is equal to very light gray.  24-bit colour consists of 8-bits of Red, 8-bit of Green, and 8-bits of Blue, meaning #FF0000 in hexadecimal is the same as Red: 255, Green: 0, Blue: 0 in decimal numbering, and #EFEFEF is the same as RED: 239, Green: 239, Blue: 239.

Comments