Category : Alternate Operating Systems - Quarterdeck DesqView, CP/M, etc
Archive   : QWHITE13.ZIP
Filename : HEX.TEC

 
Output of file : HEX.TEC contained in archive : QWHITE13.ZIP

ID:HX Hexadecimal Numbers and QEMM
Quarterdeck Technical Note #190 Filename: HEX.TEC
by Vernon Balbert CompuServe:
Last revised: 3/09/92 Category: MIS

Subject: An explanation of the hexadecimal numbering system, and how it
relates to QEMM-386, DESQview, QRAM, and Manifest.


Q: Why are these numbers mixed up with these letters and what do they mean?

A: These numbers and letters are part of a numbering system that is used by
computers.

Computers don't count the way people do. People use decimal, or base 10
for counting and we use the numbers 0-9 giving us 10 different symbols for
counting. Computers, on the other hand, use binary, a number system that uses
just zeros and ones. So, a typical binary number might look like this:

1001011011010010

Kind of confusing, huh? Well, even to programmers, these numbers are
confusing. People just don't work well with binary. Computers do. Binary
numbers can be translated to decimal quite easily, but they just aren't neat.
For instance, if you use an eight digit binary number, you can count up to
255. Well, this has three decimal numbers and multiples of 256 (counting 0)
is just not very neat or easy. However, there is a different way of counting
that is widely used by computer people. This is called HEXADECIMAL.
Hexadecimal is base 16. What this means is that if you were to start counting
from 0, you would continue up to some single digit that would represent 15.
And that's where the letters come from. Hexadecimal numbers go like this:

0 1 2 3 4 5 6 7 8 9 A B C D E F

Well, part of that looks normal, at least until the 9. The A translates
as 10, the B as 11 on up until the F is equal to 15. After F, you tack on a 1
at the beginning of the number just like we do so you would get 10. And, yes,
10 plus 10 equal 20. Since 10 in hexa- decimal is equal to 16 in decimal, it
would be logical to assume that if 16+16=32 then 20 hexadecimal equals 32
decimal. Rest assured, it does. Often, to tell the difference between
hexadecimal and decimal numbers, programmers will use H at the end of the
number to say that it is hexadecimal, i.e. 10H. Now, if you have 8 binary
numbers, you can count either to 256, or to FFH. (Remember, the H stands for
hexadecimal.) This means that you can count in multiples of 4 binary digits
with one hexadecimal digit. For instance:

10010110=96H=150 base 10

Now, you might ask, why use multiples of 4 binary digits? Well, the
answer is really quite simple. Computer people like to group binary numbers
in groups of eight. A hexadecimal number can represent 4 binary digits. Each
number is called a bit and each group of eight bits is a byte. And computer
memory is measured in bytes. Each byte can represent one character such as
the letter "Q" or the number "3". Your hard disk is measured in megabytes, or
millions of bytes. So, hexadecimal is a number system that both computers
and humans can work with easily. Actually, computers don't work with
hexadecimal, but most programs that work with hexadecimal numbers have
routines that translate the hexadecimal numbers to binary for the computer
because it's so easy; simply convert each hex digit into the appropriate 4
binary digits. By the way, hexadecimal is often referred to as "hex" for
short.

Okay, now we have to delve a little into the history of IBM PCs to
understand the way you address memory.

When IBM first came out with the PC, the Intel 8088 processor was used.
The 8088 can access 1 megabyte of memory. However, the chip only has 16 bit
registers. (A register is an internal memory loca- tion.) You can only count
to 65535 with 16 bits. In order to access the 20 bits outside the
microprocessor, an alternate method of ad- dressing memory was developed. So,
addresses had the following format:

ssss:oooo

The first four hex digits (ssss) are the segment address. The last four
(oooo) are the offset address. Together, these can address the entire 1
megabyte space of the 8088. This is called relative addressing. You never
actually say the exact address that you are pointing at, just an address
relative to a different position. For instance, if you have an address such
as 1234:2319, you would take 1234H, add a 0 to the end so it turns into 12340H
and then add 2319H to it to get 14659H.

When the 80286 came out, it had 24 address lines to address more than the
1 megabyte of memory available. (24 address lines lets you address 16
megabytes of memory.) Additionally, the internal registers were enlarged to 24
bits so you didn't have to go through the segment and offset gyrations. So,
you could now use absolute addressing. The address now takes this format:

XXXXXX

Notice now, that there are 6 digits instead of two sets of 4 when an
80286 is in "protected" mode (6 digit mode). DOS, unfortunately, only
understands segmented memory addressing which is in "real" mode. Intel built
in a "real" mode into the 80286 and higher processors so that they would still
understand relative addressing. This difference is VERY important. It is the
main reason that you can't use exTENDed memory (only available in "protected"
mode) to run DOS programs (which require "real" mode).

QEMM, QRAM and DESQview all observe the relative addressing scheme. So,
when you include or exclude areas of memory with QEMM, you use the segment
address. Typically, the only exclusions you will use involve the area above
the 640K program space. This is a 384K area of memory that is normally used
by adapter cards and ROMs in your computer. The address range of the lower
640K is 0000-9FFF. Remem-ber, these are the segment addresses, not the offset
addresses. The area above 640K is the A000-FFFF range.

Here is a translation table so you can convert some common hexadecimal
addresses into decimal and back.

Common way of Decimal Hexadecimal Segment:Offset
saying it

1K 1024 400 0040:0000 or 0000:0400
2K 2048 800 0080:0000 or 0000:0800
4K 4096 1000 0100:0000 or 0000:1000
8K 8192 2000 0200:0000 or 0000:2000
16K 16384 4000 0400:0000 or 0000:4000
32K 32768 8000 0800:0000 or 0000:8000
64K 65536 10000 1000:0000
128K 131072 20000 2000:0000
256K 262144 40000 4000:0000
384K 393612 60000 6000:0000
512K 524288 80000 8000:0000
640K 655350 A0000 A000:0000
704K 720896 B0000 B000:0000
736K 753664 B8000 B800:0000
768K 786432 C0000 C000:0000
832K 851968 D0000 D000:0000
896K 917504 E0000 E000:0000
960K 983040 F0000 F000:0000
1024K 1048576 100000 1MB and beyond cannot
be addressed with the
segment:offset method.

In summary, we see that hexadecimal (or hex, for short) is actually base 16,
decimal is base 10 and binary is base 2. Hex numbers go from 0 to F, decimal
numbers go from 0 to 9 and binary go from 0 to 1. Hex numbers are used to
make it easier for people to work with numbers that the computer uses.


************************************************************************
*This technical note may be copied and distributed freely as long as it*
*is distributed in its entirety and it is not distributed for profit. *
* Copyright (C) 1990-2 by Quarterdeck Office Systems *
************************ E N D O F F I L E *************************