Contributor: ALTON PRILLAMAN          

{
ALTON PRILLAMAN

HOWEVER,  now would be a good time to learn about "Bitwise Operators"
to accomplish your goal With minimal memory requirements.  I'll start With
the basics (no offense intended).  You may have heard, or remember from a
Programming class that a Byte is made up of 8 bits.  When looking at a Byte
in binary, each bit holds a value of 0 or 1 that when put together in
their respective places will add up to make the number.  Here's an
example of a Byte:

                               B I N A R Y
                                T A B L E
=========================================================================

             Power |   7   6   5   4   3   2   1   0 | of 2
             ------+---------------------------------+-----
             Bit # |   8   7   6   5   4   3   2   1 |
             ------+---------------------------------+-----
             Value | 128  64  32  16   8   4   2   1 | HEX
             ------+---------------------------------+-----
                0  |   0   0   0   0   0   0   0   0 | $00
                1  |   0   0   0   0   0   0   0   1 | $01
            *   2  |   0   0   0   0   0   0   1   0 | $02
                3  |   0   0   0   0   0   0   1   1 | $03
            *   4  |   0   0   0   0   0   1   0   0 | $04
                5  |   0   0   0   0   0   1   0   1 | $05
                6  |   0   0   0   0   0   1   1   0 | $06
                7  |   0   0   0   0   0   1   1   1 | $07
            *   8  |   0   0   0   0   1   0   0   0 | $08
                9  |   0   0   0   0   1   0   0   1 | $09
               10  |   0   0   0   0   1   0   1   0 | $0A
               11  |   0   0   0   0   1   0   1   1 | $0B
               12  |   0   0   0   0   1   1   0   0 | $0C
               13  |   0   0   0   0   1   1   0   1 | $0D
               14  |   0   0   0   0   1   1   1   0 | $0E
               15  |   0   0   0   0   1   1   1   1 | $0F
            *  16  |   0   0   0   1   0   0   0   0 | $10
                   |                                 |
            *  32  |   0   0   1   0   0   0   0   0 | $20
            *  64  |   0   1   0   0   0   0   0   0 | $40
            * 128  |   1   0   0   0   0   0   0   0 | $80
                   |                                 |
              255  |   1   1   1   1   1   1   1   1 | $FF
             ------+---------------------------------+-----

 * = All columns to the right had filled up With 1s, so we carried to the
     next column to the left.

Notice that when all of the "bit places" have a "1" in them, that the
total adds up to be 255 which is the maximum number that a Byte can hold.
In binary (the inner part of the Chart), "1" is the maximum value a bit
can hold Until it carries to the next column to the left.  This brings us
to the next Chart, HEXIDECIMAL:


                          H E X I D E C I M A L
                                T A B L E
=========================================================================

            Power| 1   0   |of 16        Power|  1  0   |of 16
          -------+---------+-----      -------+---------+-----
          Decimal|         |           Decimal|         |
            Value| 16  0   | HEX         Value| 16  0   | HEX
          -------+---------+-----      -------+---------+-----
                0|  0  0   | $00            31|  1  1   |  $1F
                1|  0  1   | $01         *  32|  2  0   |  $20
                2|  0  2   | $02            33|  2  1   |  $21
                3|  0  3   | $03              |         |
                4|  0  4   | $04            47|  2  F   |  $2F
                5|  0  5   | $05         *  48|  3  0   |  $30
                6|  0  6   | $06            63|  3  F   |  $3F
                7|  0  7   | $07         *  64|  4  0   |  $40
                8|  0  8   | $08            79|  4  F   |  $4F
                9|  0  9   | $09            80|  5  0   |  $50
               10|  0  A   | $0A            95|  5  F   |  $5F
               11|  0  B   | $0B         *  96|  6  0   |  $60
               12|  0  C   | $0C           111|  6  F   |  $6F
               13|  0  D   | $0D         * 112|  7  0   |  $70
               14|  0  E   | $0E           127|  7  F   |  $7F
               15|  0  F   | $0F         * 128|  8  0   |  $80
           *   16|  1  0   | $10           255|  F  F   |  $FF
               17|  1  1   | $11         * 256|         |$0100
          -------+---------+-----      -------+---------+-----

 * = All columns to the right had filled up With 15 (F) so we carried
     to the next column to the left.

The hexidecimal table is derived from BASE 16.  The value that each column
may hold a value of 15 (F) before we carry to the next column.  Also
notice that when both columns fill up With a value of "F" ($FF) that the
result is 255, which is the maximum For a Byte.


Okay, With that behind us, let's take a look at your application.  As you
may have noticed in the binary table in the previous message, a Byte will
give us the ability to track up to 8 bits.  Our goal here is to turn on or
off each of the 8 bits as each channel is turned on or off.  I assume that
you've got 16 channels to work With, so we'll use a Word instead of a
Byte.  When looked at in binary, a Word is like placing two Bytes
side-by-side.  Notice that the HEXIDECIMAL works the same way.

   256-------------------------+  +---------------------------- 128
   512----------------------+  |  |  +-------------------------  64
  1024-------------------+  |  |  |  |  +----------------------  32
  2048----------------+  |  |  |  |  |  |  +-------------------  16
  4096-------------+  |  |  |  |  |  |  |  |  +----------------   8
  8192----------+  |  |  |  |  |  |  |  |  |  |  +-------------   4
 16384-------+  |  |  |  |  |  |  |  |  |  |  |  |  +----------   2
 32768----+  |  |  |  |  |  |  |  |  |  |  |  |  |  |  +-------   1
          |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
          |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
 Power | 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0|of 2
-------+------------------------------------------------+-------
 Bit # | 16 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1|
-------+------------------------------------------------+-------
Decimal|                                                |
  Value|                   BINARY                       |   HEX
-------+------------------------------------------------+-------
      1|  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  1| $0001
      2|  0  0  0  0  0  0  0  0  0  0  0  0  0  0  1  0| $0002
      4|  0  0  0  0  0  0  0  0  0  0  0  0  0  1  0  0| $0004
      8|  0  0  0  0  0  0  0  0  0  0  0  0  1  0  0  0| $0008
     16|  0  0  0  0  0  0  0  0  0  0  0  1  0  0  0  0| $0010
     32|  0  0  0  0  0  0  0  0  0  0  1  0  0  0  0  0| $0020
     64|  0  0  0  0  0  0  0  0  0  1  0  0  0  0  0  0| $0040
    128|  0  0  0  0  0  0  0  0  1  0  0  0  0  0  0  0| $0080
    256|  0  0  0  0  0  0  0  1  0  0  0  0  0  0  0  0| $0100
    512|  0  0  0  0  0  0  1  0  0  0  0  0  0  0  0  0| $0200
   1024|  0  0  0  0  0  1  0  0  0  0  0  0  0  0  0  0| $0400
   2048|  0  0  0  0  1  0  0  0  0  0  0  0  0  0  0  0| $0800
   4096|  0  0  0  1  0  0  0  0  0  0  0  0  0  0  0  0| $1000
   8192|  0  0  1  0  0  0  0  0  0  0  0  0  0  0  0  0| $2000
  16384|  0  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0| $4000
  32768|  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0| $8000
-------+------------------------------------------------+-------

Though it has taken us a While to get here, you now have a "value" for
each of your midi channels.  if you need to use more than 16 channels, you
can use the same methods applied above using a LongInt to give you a total
of 32 channels (or bits).

You can now declare these as Constants in your Program like so:
}

Program MidiStuff;
Const
   {Midi Channels}
   Ch1  = $0001;
   Ch2  = $0002;
   Ch3  = $0004;
   Ch4  = $0008;
   Ch5  = $0010;
   Ch6  = $0020;
   Ch7  = $0040;
   Ch8  = $0080;
   Ch9  = $0100;
   Ch10 = $0200;
   Ch11 = $0400;
   Ch12 = $0800;
   Ch13 = $1000;
   Ch14 = $2000;
   Ch15 = $4000;
   Ch16 = $8000;

Var
  MidiChannels : Word;

{ Now you can turn on or off each channel and check to see if one is set by
using the following Procedures and Functions.  You can accomplish this by
using the or and and operators. }

Function ChannelIsOn(Ch : Word) : Boolean;
begin
   ChannelIsOn := (MidiChannels and Ch = Ch);
end;

Procedure TurnOnChannel(Ch : Word);
begin
   MidiChannels := MidiChannels or Ch;
end;

Procedure TurnOffChannel(Ch : Word);
begin
   MidiChannels := MidiChannels and not Ch;
end;

begin
   MidiChannels := $0000; {Initialize MidiChannels - No channels on!}
   TurnOnChannel(Ch2);
   if ChannelIsOn(Ch2) then
     Writeln('Channel 2 is on!')
   else
     Writeln('Channel 2 is off!');
   if ChannelIsOn(Ch3) then
     Writeln('Channel 3 is on!')
   else
     Writeln('Channel 3 is off!');
   TurnOnChannel(Ch16);
   TurnOnChannel(Ch10);
   TurnOffChannel(Ch2);
   if ChannelIsOn(Ch2) then
     Writeln('Channel 2 is on!')
   else
     Writeln('Channel 2 is off!');
end.