                            ┌┬────────────────┬┐                              
                            ││ Watch: Monitor ││                              
                            └┴────────────────┴┘                              
                                                                              
    Function key usage                                       Mouse            
                                                                              
   F1     - Display this help information.                  [Help]            
   F2     - Clear display and buffer.                       [Clear]           
   F3     - Exit program.                                   [Exit]            
   F4     - Write buffer contents to disk as MIDI file.     [Write]           
   F5     - Re-enable incoming display.                     [Monitor]         
   F6     - Switch to programming screen.                   [Program]         
   F7     - Toggle MIDI thru on/off.                        [Thru]            
   F8     - Toggle real-time messages on/off.               [RealTime]        
   Alt-F1 - Toggle decimal/hexadecimal numbers.             [Hex/Dec]         
   Alt-F2 - Same as F7.                                                       
   Alt-F3 - Push to DOS.                                    [Push]            
   Alt-F4 - Write buffer to disk as binary data.                              
   Alt-F8 - Send all-notes-off message (on all channels).                     
   Alt-1,...Alt-9, Alt-0 -                                                    
            Send MIDI data.  See programming screen help.    1 2 3 ...        
   Home   - Top of review buffer.                           [Top]             
   End    - Bottom of buffer.                               [Bot]             
   Up arrow   - Scroll up one line in buffer.               [LnUp]            
   Down arrow - Scroll down one line in buffer.             [LnDn]            
   PgUp   - Page up one screen in buffer.                   [PgUp]            
   PgDn   - Page down one screen in buffer.                 [PgDn]            
                                                                              
 ┌─────────┐                                                                  
 │ Display │                                                                  
 └─────────┘                                                                  
                                                                              
 The "Monitor" screen is where the principal activity takes place in Watch.   
 All incoming MIDI messages are displayed here.  Messages are translated into 
 readable abbreviations of their commonly used names.  For example, a program 
 change on channel 1 for instrument 0 is represented: "1:ProgCh/00".  All     
 such channel messages are displayed with a channel number prefix.  Note-on   
 messages are shown as channel:note+velocity.  For example, a middle C note   
 with velocity 40 played on channel 1 would be displayed "1:C3+40".  Note-off 
 messages are shown with a minus sign instead, and velocity would only be     
 shown if non-zero.  A channel number of 99 indicates that no status byte was 
 received, so the channel in use cannot be determined (note on is assumed for 
 the initial running status).                                                 
                                                                              
 Note:  C3 is defined as MIDI note number 60 (decimal).  This is not a fixed  
 standard.  Some manufacturers use C4 to identify middle C, though it is      
 still MIDI note 60.                                                          
                                                                              
 Messages other than note on/off containing 1 or 2 data bytes are shown as    
 the message name (possibly prefixed with the channel), followed by the data  
 bytes (separated by "/").  If you are unsure of a message abbreviation,      
 switch to the review buffer (by pressing any of the buffer control keys) and 
 the message will appear fully named.  The data portion of system exclusive   
 messages longer than 256 bytes (or ones received in rapid succession) will   
 not be displayed at the time the message is received; use the review buffer  
 to examine them.                                                             
                                                                              
 General status information appears on the line below the display area.  This 
 includes thru status, real-time mode, number base for MIDI data, and the     
 current size of the review buffer as a percentage from 0 to 100.  "Thru:On"  
 indicates that all data received from MIDI IN will be resent through MIDI    
 OUT. IMPORTANT: Thru should always be turned OFF when receiving data dumps   
 from a MIDI device.  "RealTime:Pass" indicates that system real-time         
 messages, such as MIDI Clock and Active Sensing, are to be received and      
 displayed.  "RealTime:Block" prevents all real-time messages from being      
 received (regardless of the individual settings on the Programming screen).  
 The MIDI number base is indicated as "HEX" or "DEC" (toggled by Alt-F1).     
 "HEX: indicates that MIDI data bytes are to be displayed in hexadecimal      
 (base 16: 0-9,A-F).  "DEC" indicates base 10 display of MIDI data bytes.     
 Note: Channel numbers are ALWAYS shown in decimal, from 1 to 16.             
                                                                              
 ┌───────────────┐                                                            
 │ Review Buffer │                                                            
 └───────────────┘                                                            
                                                                              
 Pressing any of the buffer control keys (Home, End, up/down arrow, PgUp,     
 PgDn) will switch into buffer review mode.  On a color display, review text  
 will appear in cyan (light blue), compared to white for normal monitoring.   
 In this mode, you can move around in the buffer and examine the received     
 data in full detail.  Each line will generally show one MIDI event, together 
 with the reference time at which the event was received (as min:sec.ms).     
                                                                              
 The contents of system exclusive messages are shown 10 bytes per line, with  
 the System Exclusive and End Exclusive portions displayed on separate,       
 time-stamped lines.  The data byte lines in between are sequenced, starting  
 at 1.  Following each set of 10 data values is the same data represented as  
 ASCII characters.  Non-printable characters are displayed as dots.           
                                                                              
 The buffer can hold approximately 8100 MIDI events, including about 70,000   
 bytes of system exclusive data.  When the buffer limit is exceeded, the      
 oldest data is discarded to make room for new incoming data.  Data continues 
 to be received while in review mode, and moving down in the buffer will show 
 any new data.  To switch back to normal monitoring, press F5 (Monitor).  To  
 clear the buffer entirely, press F2 (Clear).                                 
                                                                              
 To write the buffer contents to a file, press F4 (Write).  This will prompt  
 for a file name, and then write the data to disk in standard MIDI file       
 format.  This data can be subsequently resent, using this program, or any    
 other program (such as a sequencer) which supports standard MIDI files.      
 Since all events are time-stamped, timing information is recorded along with 
 the MIDI data.  Sending MIDI data (see below) resets the buffer reference    
 time.  If more events are received after a send, later data can actually     
 have earlier reference times.  In this case, buffer times are adjusted when  
 writing so that all saved event times are increasing.  MIDI files written    
 are limited by the program to about 65,000 bytes in size.                    
                                                                              
 To write the buffer to disk in simple binary format (sometimes referred to   
 as MIDIEX format), press Alt-F4 and enter the file name when prompted.  Such 
 data can be resent later, as with standard MIDI files.  Binary files up to   
 the full size of the buffer can be written.                                  
                                                                              
 ┌───────────────────┐                                                        
 │ Sending MIDI data │                                                        
 └───────────────────┘                                                        
                                                                              
 Using the "Programming" screen, up to 10 "send keys" can be defined.  These  
 keys are Alt-1 thru Alt-9 and Alt-0 (press Alt and then a number).  They may 
 be defined as a MIDI byte sequence, or the name of a file.  When the key is  
 pressed (or the digit selected if using a mouse), the defined data is sent.  
 When a file is used, it may be either a standard MIDI format file, or a raw  
 binary data file (a stream of MIDI bytes).  MIDI files are loaded, and their 
 contents sent according to the times defined in the file.                    
                                                                              
 You may do other things while sending non-system exclusive data from a MIDI  
 file, including receiving new data into the buffer.  Sending a manually      
 entered sequence, data from a binary file, or a system exclusive message     
 within a MIDI file will stop other operations until done.  Pressing any key  
 will end such an operation.  To completely stop a MIDI file send, press the  
 key which initiated it (F2 will also stop it).                               
                                                                              
 The speed at which MIDI file system exclusive data, binary file data, and    
 manual data are sent is determined by the "Bytes/sec" value on the           
 programming screen.  The normal MIDI data rate is 3125 bytes per second.     
 Some devices cannot keep up with this rate when receiving bulk data.  In     
 that case, try lower speed settings until a successful transfer is obtained. 
 A delay before sending a system exclusive message may also need to be        
 employed; use the "SysEx wait" value for this.                               
                                                                              
 ┌───────────┐                                                                
 │ Filtering │                                                                
 └───────────┘                                                                
                                                                              
 Various operations can be automatically performed on the incoming MIDI data  
 as defined on the Programming screen.  For example, you can redirect data    
 from one channel to another, transpose notes, scale velocities, select       
 ranges of notes, and block certain types of MIDI messages.  Press F6         
 (Program) to switch to the programming screen.  Press F1 (Help) there for    
 further information.                                                         
                                                                              
 ┌──────────────────────┐                                                     
 │ Preventing Data loss │                                                     
 └──────────────────────┘                                                     
                                                                              
 Use care when receiving large bulk dumps from a MIDI device.  In some cases  
 it is possible that the screen display may get behind the data reception,    
 causing data overruns (missed data).  This might happen, for example, on     
 slower machines receiving many small system exclusive messages.  One option  
 is to switch to the Programming screen before initiating the dump at the     
 device; this will minimize screen updating delays.  Also, be sure that Watch 
 is being run "interrupt-driven".  This is the default mode - used whenever   
 possible - however it is possible that Watch was not able to detect the      
 proper interrupt (or IRQ) number and switched to "polled" mode.  On slower   
 machines this may cause data to be lost.  To check, run Watch with the -v    
 option to display device information at start up.  If it says "IRQ: none",   
 polled mode is being used.  You may need to use the -d option (see Command   
 line usage) to force the proper IRQ selection.                               
                                                                              
 If you are trying to save an important dump, such as the factory settings of 
 a device, it is a good idea to test the dump by sending it twice and saving  
 it to two different files.  Then compare these file using the DOS FC         
 command:   FC file1 file2                                                    
                                                                              
 This will only work with binary files - slight timing variations recorded in 
 standard MIDI files will cause bad compares, even though the actual data is  
 the same.                                                                    
                                                                              
 So a cautious procedure would be:  [1] receive dump, [2] write buffer to     
 binary file (Alt-F4), [3] clear buffer (F2), [4] receive dump again, [5]     
 write to second binary file, [6] write to standard MIDI file (if desired),   
 [7] exit and compare binary files.  This procedure should be followed until  
 you are confident that all your dumps are being received correctly.          
                                                                              
 ┌────────────────────┐                                                       
 │ Command line usage │                                                       
 └────────────────────┘                                                       
                                                                              
 WATCH <-options>                                                             
                                                                              
 <-options> may be any of the following:                                      
                                                                              
 -d  Selects the MIDI interface to use if more than one is present in the     
     system:                                                                  
                                                                              
              -dmfc      selects IBM Music Feature                            
              -dmpu      selects MPU-401 compatible                           
              -dmidiator selects MIDIator                                     
              -dsbmidi   selects Sound Blaster MIDI                           
                                                                              
              (The first 3 letters of the device name are sufficient.)        
                                                                              
     The MIDIator cannot be detected automatically and the -dmid option       
     must always be specified if one is in use.                               
                                                                              
     Non-standard IRQ and I/O port address information can be added following 
     the device id if necessary:                                              
                                                                              
              -dxxx:<irq>:<ioaddr>                                            
                                                                              
     For example, to define an MPU-compatible interface using IRQ 5 and I/O   
     address 332 (hex), use:                                                  
                                                                              
              -dMPU:5:332                                                     
                                                                              
     If only the I/O address is required but the default IRQ is alright,      
     use -dMPU::332.                                                          
                                                                              
     The irq and ioaddr are not relevant to the MIDIator, though the first    
     option number can be given to indicate use of the com port 2 instead of  
     the default com 1.  (ex: -dmid:2)                                        
                                                                              
 -i  Try to determine the IRQ in use automatically (MPU and MFC only).        
                                                                              
 -v  List the type of interface actually selected before starting.            
                                                                              
 -k  Forces keyboard mode if a mouse is present.                              
                                                                              
 -m  Forces monochrome mode (mono mode is automatically detected).            
                                                                              
  Separate all options with at least one space.                               
                                                                              
 ---------------------------------------------------------------------------  
