``````{
>Also, how would I simply read each bit?
}
{ Test if a bit is set. }
Function IsBitSet(Var INByte : Byte; Bit2Test : Byte) : Boolean;
begin
if (Bit2Test in [0..7]) then
IsBitSet := ((INByte and (1 shl Bit2Test)) <> 0)
else
Writeln('ERROR! Bit to check is out of range!');
end; { IsBitSet. }

{
>How on earth can I manipulate an individual bit?

...One method is to use the bit-operators:  AND, OR, XOR, NOT
}

{ Manipulate an individual BIT within a single Byte. }
Procedure SetBit(Bit2Change : Byte; TurnOn : Boolean; Var INByte : Byte);
begin
if Bit2Change in [0..7] then
begin
if TurnOn then
INByte := INByte or (1 shl Bit2Change)
else
INByte := INByte and NOT(1 shl Bit2Change);
end;
end; { SetBit. }

{
>...but I'm not sure exactly what the shifting is doing.
}

{ Check if the bit is to be turned on or off. }
If TurnOn then

{
SHL 1 (which has a bit map of 0000 0001) to the bit
position we want to turn-on.

ie: 1 SHL 4 = bit-map of 0001 0000

...Then use a "logical OR" to set this bit.

ie: Decimal:     2      or      16     =    18
Binary : 0000 0010  or  0001 0000  = 0001 0010
}

INByte := INByte or (1 shl Bit2Change)
else

{
Else turn-off bit.

SHL 1 (which has a bit map of 0000 0001) to the bit
position we want to turn-off.

ie: 1 SHL 4 = bit-map of 0001 0000

...Then use a "logical NOT" to flip all the bits.

ie: Decimal:  not (   16    ) =      239
Binary :  not (0001 0000) =  (1110 1111)

...Than use a "logical AND" to turn-off the bit.

ie: Decimal:     255     and     239    = 239
Binary :  1111 1111  and  1110 1111 = 1110 1111
}

INByte := INByte and NOT(1 shl Bit2Change);

{
>Also, how can you assign a Byte (InByte) a Boolean value (OR/AND/NOT)

or / xor / and / not are "logical" bit operators, that can be use on
"scalar" Types. (They also Function in the same manner For "Boolean"
logic.)

>If I have, say 16 bits in one Byte, the interrupt list says that for
>instance the BIOS calls (INT 11), AX is returned With the values. It
>says that the bits from 9-11 tell how many serial portss there are.
>How do I read 3 bits?

To modify the two routines I posted wo work With 16 bit Variables,
you'll need to change:

INByte : Byte;  --->  INWord : Word;

...Also:

in [0..7]  --->  in [0..15]

...If you don't want to use the IsBitSet Function listed above
(modified to accept 16-bit Word values) you could do the following
to check if bits  9, 10, 11 are set in a 16-bit value:

The following is the correct code For reading bits 9, 10, 11
of the 16-bit Variable "AX_Value" :

Port_Count :=  ((AX_Value and \$E00) SHR 9);

NOTE: Bit-map For \$E00 = 0000 1110 0000 0000

...If you've got a copy of Tom Swan's "Mastering Turbo Pascal",
check the section on "logical operators".

{
>Var Regs : Registers;
>begin
>  Intr(\$11,Regs);
>  Writeln(Regs.AX);
>end.

>How do I manipulate that to read each bit (or multiple bits like
>the number of serial ports installed (bits 9-11) ?
}

Uses
Dos;

Var
Port_Count : Byte;
Regs       : Registers;

begin
Intr(\$11, Regs);
Port_Count := ((Regs.AX and \$E00) SHR 9);
Writeln('Number of serial-ports = ', Port_Count)
end.
{
NOTE: The hex value of \$E00 is equivalent to a 16-bit value with
only bits 9, 10, 11 set to a binary 1. The SHR 9 shifts the
top Byte of the 16-bit value, to the lower Byte position.
}
{
>Is \$E00 the same as \$0E00 (ie, can you just omit leading zeros)?

Yeah, it's up to you if you want to use the leading zeros or not.

The SHR 9 comes in because once the value has been "AND'd" with
\$E00, the 3 bits (9, 10, 11) must be placed at bit positions:
0, 1, 2  ...to correctly read their value.

For example, say bits 9 and 11 were set, but not bit 10. If we
"AND" this With \$E00, the result is \$A00.

1011 1010 0111 1110  and  0000 1110 0000 0000  =  0000 1010 0000 0000
^ ^
(bits 9,11 are set)  and  (      \$E00       )  =  \$A00
...Taking the result of \$A00, and shifting it right 9 bit positions

\$A00         SHR 9  =           5

0000 1010 0000 0000  SHR 9  =  0000 0000 0000 0101

...Which evalutates to 5. (ie: 5 serial ports)
}

{
Get Equipment Bit-Map
---------------------

AH       AL
76543210 76543210
AX =  ppxgrrrx ffvvmmci

...
...
rrr = # of RS232 ports installed
...
...

(* reports the number of RS232 ports installed *)
Function NumRS232 : Byte;
Var Regs : Registers;                 (* Uses Dos *)
begin
Intr(\$11,Regs);
NumRS232 := (AH and \$0E) shr 1;
end;

...When you call Int \$11, it will return the number of RS232 ports installed
in bits 1-3 in register AH.

For example if AH = 01001110 , you can mask out the bits you *don't* want
by using AND, like this:

01001110      <---  AH
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄ

Then shift the bits to the right With SHR,

SHR         1      <---- shift-right one bit position
ÄÄÄÄÄÄÄÄÄÄÄÄÄ
00000111      <---- result you want
}

{
-> How do I know to use \$4 For the third bit?  Suppose I want to read
-> the fifth bit. Do I simply use b := b or \$6?

Binary is a number system just like decimal.  Let me explain.
First, consider the number "123" in decimal.  What this means,
literally, is

1*(10^2) + 2*(10^1) + 3*(10^0), which is 100 + 20 + 3.

Binary works just the same, however instead of a 10, a 2 is used as
the base.  So the number "1011" means

1*(2^3) + 0*(2^2) + 1*(2^1) + 1*(2^0), or 8+0+2+1, or 11.

This should make it clear why if you wish to set the nth bit to
True, you simply use a number equal to 2^(n-1).  (The -1 is there
because you probably count from 1, whereas the powers of two, as you may
note, start at 0.)

-> b or (1 SHL 2) Would mean that b := 1 (True) if b is already equal to
-> one (1) and/OR the bit two (2) to the left is one (1) ???

Aha.  You are not familiar With bitwise or operations.  When one
attempts to or two non-Boolean values (Integers), instead of doing a
logical or as you are familiar with, each individual BIT is or'd.  I.E.
imagine a Variables A and B had the following values:

a := 1100 (binary);
b := 1010 (binary);

then, a or b would be equal to 1110 (binary);  Notice that each bit of a
has been or'd With the corresponding bit of b?  The same goes For and.
Here's an example.

a := 1100 (binary);
b := 1010 (binary);

a and b would be equal to 1000;

I hope this clears up the confusion.  And just to be sure, I'm going to
briefly show a SHL and SHR operation to make sure you know.  Consider
the number

a := 10100 (binary);

This being the number, A SHL 2 would be equal to 1010000 (binary) --
notice that it has been "shifted to the left" by 2 bits.

A SHR 1 would be 1010 (binary), which is a shifted to the right by 2
bits.
}

``````