path: root/mapping.txt

 MEMORY MAP

 Locations zero to 255 ($0 to $FF) are called "page zero" and have
 special importance for assembly language programmers since these
 locations are accessed faster and easier by the machine.

 Locations zero to 127 ($0 to $7F) are reserved as the OS page zero,
 while 128 to 255 ($80 to $FF) are the BASIC and the user zero page
 RAM. Locations zero to 1792 ($0 to $700) are all used as the OS and (if
 the cartridge is present) 8K BASIC RAM (except page six). Locations
 zero to 8191 ($0 to $1FFF) are the minimum required for operation
 (8K).

 Locations two through seven are not cleared on any start operation.

 DECIMAL        HEX            LABEL

 0,1             0,1             LINZBS

      LINBUG RAM, replaced by the monitor RAM See the OS
      Listing, page 31. It seems to be used to store the VBLANK timer
      value. One user application I've seen for location zero is in a
      metronome program in De Re Atari. Also used in cross-
      assembling the Atari OS.


 2,3             2,3             CASINI

      Cassette initialization vector: JSR through here if the cassette
      boot was successful. This address is extracted from the first six
      bytes of a cassette boot file. The first byte is ignored. The second
      contains the number of records, the third and fourth contain the
      low and high bytes of the load address, and the fifth and sixth
      contain the low and high bytes of the initialization address.
      Control upon loading jumps to the load address plus six for a
      multi-stage load and through CASINI for initialization. JSR
      through DOSVEC (10 and 11; $A,$B) to transfer control to the
      application.


 4,5             4,5             RAMLO

      RAM pointer for the memory test used on powerup. Also used to
      store the disk boot address--normally 1798 ($706)--for the
      boot continuation routine.


 6               6               TRAMSZ

      Temporary Register for RAM size; used during powerup
      sequence to test RAM availability. This value is then moved to
      RAMTOP, location 106 ($6A). Reads one when the BASIC or the
      A (left) cartridge is plugged in.


 7               7               TSTDAT

      RAM test data register. Reads one when the B or the right
      cartridge is inserted.

      RAMLO, TRAMSZ and TSTDAT are all used in testing the RAM
      size on powerup. On DOS boot, RAMLO and TRAMSZ also act as
      temporary storage for the boot continuation address. TRAMSZ
      and TSTDAT are used later to flag whether or not the A (left)
      and/or B (right) cartridges, respectively, are plugged in (non-
      zero equals cartridge plugged in) and whether the disk is to be
      hooted.

 Locations eight through 15 ($8-$F) are cleared on coldstart only.


 8               8               WARMST

      Warmstart flag. If the location reads zero, then it is in the middle
      of powerup; 255 is the normal RESET status. Warmstart is similar
      to pressing RESET, so should not wipe out memory, variables, or
      programs. WARMST is initialized to zero and will not change
      values unless POKEd or until the first time the RESET button is
      pressed. It will then read 255 ($FF).

      Warmstart normally vectors to location 58484 ($E474). WARMST
      is checked by the NMI status register at 54287 ($D40F) when
      RESET is pressed to see whether or not to re-initialize the
      software or to re-boot the disk.


 9               9               BOOT?

      Boot flag success indicator. A value of 255 in this location will
      cause the system to lockup if RESET is pressed. If BOOT? reads
      one, then the disk boot was successful; if it reads two, then the
      cassette boot was successful. If it reads zero, then neither
      peripheral was booted.

      If it is set to two, then the cassette vector at locations two and
      three will be used on RESET. Set to one, it will use the DOS
      vector at 10 and 11 ($A and $B). Coldstart attempts both a
      cassette and a disk boot and flags this location with the success or
      failure of the boots. BOOT? is checked during both disk and
      cassette boot.


 10,11           A,B             DOSVEC

      Start vector for disk (or non-cartridge) software. This is the
      address BASIC jumps to when you call up DOS. Can be set by
      user to point to your own routine, but RESET will return DOSVEC
      to the original address. To prevent this, POKE 5446 with the LSB
      and 5450 with the MSB of your vector address and re-save DOS
      using the WRITE DOS FILES option in the menu. Locations 10
      and 11 are usually loaded with 159 and 23 ($9F and $17),
      respectively. This allows the DUPSYS section of DOS to be
      loaded when called. It is initially set to blackboard mode vector
      (58481; $E471--called by typing "BYE" or "B." from BASIC); it
      will also vector to the cassette run address if no DOS vector is
      loaded in. If you create an AUTORUN.SYS file that doesn't end
      with an RTS instruction, you should set BOOT? to one and 580
      ($244) to zero.


 12,13           C,D             DOSINI

      Initialization address for the disk boot. Also used to store the
      cassette-boot RUN address, which is then moved to CASINI (2,
      3). When you powerup without either the disk or an autoboot
      cassette tape, DOSINI will read zero in both locations.


 14,15           E,F             APPMHI

      Applications memory high limit and pointer to the end of your
      BASIC program, used by both the OS and BASIC. It contains the
      lowest address you can use to set up a screen and Display List
      (which is also the highest address usable for programs and data
      below which the display RAM may not be placed). The screen
      handler will not OPEN the "S:" device if it would extend the
      screen RAM or the Display List below this address; memory
      above this address may be used for the screen display and other
      data (PM graphics, etc.).

      If an attempted screen mode change would extend the screen
      memory below APPMHI, then the screen is set up for GRAPHICS
      mode zero; MEMTOP (locations 741, 742; $2E5, $2E6) is updated
      and an error is returned to the user. Otherwise, the memory is not
      too small for the screen editor; the mode change will take effect
      and MEMTOP will be updated. This is one of five locations used
      by the OS to keep track of the user and display memory.
      Initialized to zero by the OS at powerup. Remember, you cannot
      set up a screen display below the location specified here.

      If you use the area below the Display List for your character sets,
      PM graphics or whatever, be sure to set APPMHI above the last
      address used so that the screen or the DL data will not descend
      and destroy your own data. See RAMTOP location 106 ($6A),
      MEMTOP at 741, 742 ($2E5, $2E6), PMBASE at 54279 ($D407)
      and CHBASE at 54281 ($D409) for more information.

 Locations 16 through 127 ($10-$7F) are cleared on either cold- or
 warmstart.


 16              10              POKMSK

      POKEY interrupts: the IRQ service uses and alters this location.
      Shadow for 53774 ($D20E). POKE with 112 ($70; also POKE this
      same value into 53774) to disable the BREAK key. If the following
      bits are set (to one), then these interrupts are enabled (bit
      decimal values are in parentheses):

      BIT   DECIMAL   FUNCTION
       7      128     The BREAK key is enabled.
       6       64     The "other key" interrupt is enabled.
       5       32     The serial input data ready interrupt is
                      enabled.
       4       16     The serial output data required interrupt is
                      enabled.
       3        8     The serial out transmission finished
                      interrupt is enabled.
       2        4     The POKEY timer four interrupt is enabled
                      (only in the "B" or later versions of the OS
                      ROMs).
       1        2     The POKEY timer two interrupt is enabled.
       0        1     The POKEY timer one interrupt is enabled.

      Timer interrupt enable means the associated AUDF registers are
      used as timers and will generate an interrupt request when they
      have counted down to zero. See locations 528 to 535 ($210 to
      $217) and the POKEY chip from locations 53760 ($D200) on, for a
      full explanation. 192 ($C0) is the default on powerup.

      You can also disable the BREAK key by POKEing here with 64
      ($40; or any number less than 128; $80) and also in location
      53774. The problem with simple POKEs is that the BREAK key is
      re-enabled when RESET is pressed and by the first PRINT
      statement that displays to the screen, or any OPEN statement that
      addresses the screen (S: or E:), or the first PRINT statement after
      such an OPEN and any GRAPHICS command. In order to
      continually disable the BREAK key if such commands are being
      used, it's best to use a subroutine that checks the enable bits
      frequently during input and output operations, and POKEs a
      value less than 128 into the proper locations, such as:

      1000   BREAK = PEEK(16) - 128: IF BREA
             K < 0 THEN RETURN
      1010   POKE 16, BREAK: POKE 53774, BRE
             AK: RETURN

      The new OS "B" version ROMs have a vector for the BREAK key
      interrupt, which allows users to write their own routines to
      process the interrupt in the desired manner. It is located at 566,
      567 ($236, $237).


 17              11              BRKKEY

      Zero means the BREAK key is pressed; any other number means
      it's not. A BREAK during I/O returns 128 ($80). Monitored by
      both keyboard, display, cassette and screen handlers. See
      location 16 ($A) for hints on disabling the BREAK key. The latest
      editions of OS provide for a proper vector for BREAK interrupts.
      The BREAK key abort status code is stored in STATUS (48; $30).
      It is also checked during all I/O and scroll/draw routines. During
      the keyboard handler routine, the status code is stored in DSTAT
      (76; $4C). BRKKEY is turned off at powerup. BREAK key abort
      status is flagged by setting BIT 7 of 53774 ($D20E). See the note
      on the BREAK key vector, above.


 18,19,20                12,13,14                RTCLOK

      Internal realtime clock. Location 20 increments every stage one
      VBLANK interrupt (1/60 second = one jiffy) until it reaches 255
      ($FF); then location 19 is incremented by one and 20 is reset to
      zero (every 4.27 seconds). When location 19 reaches 255, it and
      20 are reset to zero and location 18 is incremented by one (every
      18.2 minutes or 65536 TV frames). To use these locations as a
      timer of seconds, try:

      TIME = INT((PEEK(18) * 65536 + PEEK(19) * 256 +
             PEEK(20) )/60)

      To see the count in jiffies, eliminate the "/60" at the end. To see
      the count in minutes, change "/60" to "/360." The maximum
      value of the RT clock is 16,777,215. When it reaches this value, it
      will be reset to zero on the next VBLANK increment. This value is
      the result of cubing 256 (i.e., 256 * 256 * 256), the maximum
      number of increments in each clock register. The RT clock is
      always updated every VBLANK regardless of the time-critical
      nature of the code being processed.

      A jiffy is actually a long time to the computer. It can perform
      upwards of 8000 machine cycles in that time. Think of what can
      be done in the VBLANK interval (one jiffy). In human terms, a
      jiffy can be upwards of 20 minutes, as witnessed in the phrase "I'll
      be ready in a jiffy." Compare this to the oft-quoted phrase, "I'll
      be there in a minute," used by intent programmers to describe a
      time frame upwards of one hour.
      Users can POKE these clock registers with suitable values for
      their own use. The realtime clock is always updated during the
      VBLANK interval. Some of the other timer registers (locations
      536 to 544; $218 to $220) are not always updated when the OS is
      executing time critical code.
      Here's one way to use the realtime clock for a delay timer:

      10 GOSUB 100
      .
      .
      .
      100 POKE 20,0: POKE 19,0
      110 IF NOT PEEK(19) THEN 110
      120 RETURN

 Line 110 waits to see if location 19 returns to zero and, when it
 does, passes control to the RETURN statement.

      See COMPUTE!, August 1982, for a useful program to create a
      small realtime clock that will continue to display during your
      BASIC programming. See also De Re Atari for another realtime
      clock application.


 21,22           15,16           BUFADR

      Indirect buffer address register (page zero). Temporary pointer
      to the current disk buffer.


 23              17              ICCOMT

      Command for CIO vector. Stores the CIO command; used to find
      the offset in the command table for the correct vector to the
      handler routine.


 24,25           18,19           DSKFMS

      Disk file manager pointer. Called JMPTBL by DOS; used as
      vector to FMS.


 26,27           1A,1B           DSKUTL

      The disk utilities pointer. Called BUFADR by DOS, it points to
      the area saved for a buffer for the utilities package (data buffer;
      DBUF) or for the program area (MEMLO; 743, 744; $2E7, $2E8).


 28              1C              PTIMOT

      Printer timeout, called every printer status request. Initialized to
      30, which represents 32 seconds (the value is 64 seconds per 60
      increments in this register); typical timeout for the Atari 825
      printer is five seconds. The value is set by your printer handler
      software. It is updated after each printer status request operation.
      It gets the specific timeout status from location 748 ($2EC), which
      is loaded there by SIO.

      The new "B" type OS ROMs have apparently solved the problem
      of timeout that haunted the "A" ROMs; you saw it when the
      printer or the disk drive periodically went to sleep (timed out) for
      a few seconds, causing severe anxiety attacks in the owners who
      thought their Ataris had just mysteriously died. This is
      compounded when one removes a disk from the drive, believing
      the I/O process to be finished--only to have the drive start up
      again after the timeout and trying to write to or read from a
      nonexistent disk. Usually both the system and the user crash
      simultaneously at this point. See the appendix for more
      information on the new ROMs.


 29              1D              PBPNT

      Print buffer pointer; points to the current position (byte) in the
      print buffer. Ranges from zero to the value in location 30.


 30              1E              PBUFSZ

      Print buffer size of printer record for current mode. Normal
      buffer size and line size equals 40 bytes; double-width print
      equals 20 bytes (most printers use their own control codes for
      expanded print); sideways printing equals 29 bytes (Atari 820
      printer only). Printer status request equals four. PBUFSZ is
      initialized to 40. The printer handler checks to see if the same
      value is in PBPNT and, if so, sends the contents of the buffer to
      the printer.


 31              1F              PTEMP

      Temporary register used by the printer handler for the value of
      the character being output to the printer.

 ----------------------------------------------------------------------

 Locations 32 to 47 ($20 to $2F) are the ZIOCB: Page zero Input-Output
 Control Block. They use the same structure as the IOCB's at locations
 832 to 959 ($340 to $3BF). The ZIOCB is used to communicate I/O con-
 trol data between CIO and the device handlers. When a CIO opera-
 tion is initiated, the information stored in the IOCB channel is moved
 here for use by the CIO routines. When the operation is finished, the
 updated information is returned to the user area.


 32              20              ICHIDZ

      Handler index number. Set by the OS as an index to the device
      name table for the currently open file. If no file is open on this
      IOCB (IOCB free), then this register is set to 255 ($FF).


 33              21              ICDNOZ

      Device number or drive number Called MAXDEV by DOS to in-
      dicate the maximum number of devices. Initialized to one.


 34              22              ICCOMZ

      Command code byte set by the user to define how the rest of the
      IOCB is formatted, and what I/O action is to be performed.


 35              23              ICSTAZ

      Status of the last IOCB action returned by the device, set by the
      OS. May or may not be the same status returned by the STATUS
      command.


 36,37           24,25           ICBALZ/HZ

      Buffer address for data transfer or the address of the file name for
      commands such as OPEN, STATUS, etc.


 38,39           26,27           ICPTLZ/HZ

      Put byte routine address set by the OS. It is the address minus
      one byte of the device's "put one byte" routine. It points to CIO's
      "IOCB not OPEN" on a CLOSE statement.


 40,41           28,29           ICBLLZ/HZ

      Buffer length byte count used for PUT and GET operations;
      decreased by one for each byte transferred.


 42              2A              ICAX1Z

      Auxiliary information first byte used in OPEN to specify the type
      of file access needed.


 43              2B              ICAX2Z

      CIO working variables, also used by some serial port functions.
      Auxiliary information second byte.


 44,45           2C,2D           ICAX3Z/4Z

      Used by BASIC NOTE and POINT commands for the transfer of
      disk sector numbers. These next four bytes to location 47 are also
      labelled as: ICSPRZ and are defined as spare bytes for local CIO
      use.


 46              2E              ICAX5Z

      The byte being accessed within the sector noted in locations 44
      and 45. It is also used for the IOCB Number multiplied by 16.
      Each IOCB block is 16 bytes long. Other sources indicate that the
      6502 X register also contains this information.


 47              2F              ICAX6Z

      Spare byte. Also labelled CIOCHR, it is the temporary storage
      for the character byte in the current PUT operation.

 -------------------------------------------------------------------


 48              30              STATUS

      Internal status storage. The SIO routines in ROM use this byte to
      store the status of the current SIO operation. See page 166 of the
      OS User's Manual for status values. STATUS uses location 793
      ($319) as temporary storage. STATUS is also used as a storage
      register for the timeout, BREAK abort and error values during
      SIO routines.


 49              31              CHKSUM

      Data frame checksum used by SIO: single byte sum with carry to
      the least significant bit. Checksum is the value of the number of
      bytes transmitted (255; $FF). When the number of transmitted
      bytes equals the checksum, a checksum sent flag is set at location
      59 ($3B). Uses locations 53773 ($D20D) and 56 ($38) for com-
      parison of values (bytes transmitted).


 50,51           32,33           BUFRLO/HI

      Pointer to the data buffer, the contents of which are transmitted
      during an I/O operation, used by SIO and the Device Control
      Block (DCB); points to the byte to send or receive. Bytes are
      transferred to the eight-bit parallel serial output holding register
      or from the input holding register at 53773 ($D20D). This register
      is a one-byte location used to hold the eight bits which will be
      transmitted one bit at a time (serially) to or from the device. The
      computer takes the eight bits for processing when the register is
      full or replaces another byte in it when empty after a
      transmission.


 52,53           34,35           BFENLO/HI

      Next byte past the end of the SIO and DCB data buffer described
      above.


 54              36              CRETRY

      Number of command frame retries. Default is 13 ($0D). This is the
      number of times a device will attempt to carry out a command
      such as read a sector or format a disk.


 55              37              DRETRY

      Number of device retries. The default is one.


 56              38              BUFRFL

      Data buffer full flag (255; $FF equals full).


 57              39              RECVDN

      Receive done flag (255; $FF equals done).


 58              3A              XMTDON

      Transmission done flag (255; $FF equals done).


 59              3B              CHKSNT

      Checksum sent flag (255; $FF equals sent).


 60              3C              NOCKSM

      Flag for "no checksum follows data." Not zero means no
      checksum follows; zero equals checksum follows transmission
      data.


 61              3D              BPTR

      Cassette buffer pointer: record data index into the portion of data
      being read or written. Ranges from zero to the current value at
      location 650 ($28A). When these values are equal, the buffer at
      1021 ($3FD) is empty if reading or full if writing. Initialized to 128
      ($80).


 62              3E              FTYPE

      Inter-record gap type between cassette records, copied from
      location 43 ($2B; ICAX2Z) in the ZIOCB, stored there from
      DAUX2 (779; $30B) by the user. Normal gaps are a non-zero
      positive number; continuous gaps are zero (negative number).


 63              3F              FEOF

      Cassette end of file flag. If the value is zero, an end of file (EOF)
      has not been reached. Any other number means it has been
      detected. An EOF record has been reached when the command
      byte of a data record equals 254 ($FE). See location 1021 ($3FD).


 64              40              FREQ

      Beep count retain register. Counts the number of beeps required
      by the cassette handler during the OPEN command for play or
      record operations; one beep for play, two for record.


 65              41              SOUNDR

      Noisy I/O flag used by SIO to signal the beeping heard during
      disk and cassette I/O. POKE here with zero for blessed silence
      during these operations. Other numbers return the beep. In-
      itialized to three. The hardware solution to this problem is to turn
      your speaker volume down. This can also be used to silence the
      digital track when playing synchronized voice/data tapes. See
      location 54018.


 66              42              CRITIC

      Critical I/O region flag; defines the current operation as a time-
      critical section when the value here is non-zero. Checked at the
      NMI process after the stage one VBLANK has been processed.
      POKEing any number other than zero here will disable the repeat
      action of the keys and change the sound of the CTRL-2 buzzer.

      Zero is normal; setting CRITIC to a non-zero value suspends a
      number of OS processes including system software timer coun-
      ting (timers two, three, four and five; see locations 536 to 558;
      $218 to $22E). It is suggested that you do not set CRITIC for any
      length of time. When one timer is being set, CRITIC stops the
      other timers to do so, causing a tiny amount of time to be "lost."
      When CRITIC is zero, both stage one and stage two VBLANK
      procedures will be executed. When non-zero, only the stage one
      VBLANK will be processed.


 67-73           43-49           FMZSPG

      Disk file manager system (FMS) page zero registers (seven
      bytes).


 67,68           43,44           ZBUFP

      Page zero buffer pointer to the user filename for disk I/O.


 69,70           45,46           ZDRVA

      Page zero drive pointer. Copied to here from DBUFAL and
      DBUFAH; 4905 and 4913 ($1329, $1331). Also used in FMS "free
      sector," setup and "get sector" routines.


 71,72           47,48           ZSBA

      Zero page sector buffer pointer.


 73              49              ERRNO

      Disk I/O error number. Initialized to 159 ($9F) by FMS.


 74              4A              CKEY

      Cassette boot request flag on coldstart. Checks to see if the
      START key is pressed and, if so, CKEY is set. Autoboot cassettes
      are loaded by pressing the START console key while turning the
      power on. In response to the beep, press the PLAY button on the
      recorder.


 75              4B              CASSBT

      Cassette boot flag. The Atari attempts both a disk and a cassette
      boot simultaneously. Zero here means no cassette boot was suc-
      cessful. See location 9


 76              4C              DSTAT

      Display status and keyboard register used by the display handler.
      Also used to indicate memory is too small for the screen mode,
      cursor out of range error, and the BREAK abort status.


 77              4D              ATRACT

      Attract mode timer and flag. Attract mode rotates colors on your
      screen at low luminance levels when the computer is on but no
      keyboard input is read for a long time (seven to nine minutes).
      This helps to save your TV screen from "burn-out" damage suf-
      fered from being left on and not used. It is set to zero by IRQ
      whenever a key is pressed, otherwise incremented every four
      seconds by VBLANK (see locations 18 - 20; $12 - $14). When the
      value in ATRACT reaches 127 ($7F), it is then set to 254 ($FE) un-
      til attract mode is terminated. This sets the flag to reduce the
      luminance and rotate the colors when the Atari is sitting idle.
      POKE with 128 ($80) to see this effect immediately: it normally
      takes seven to nine minutes to enable the attract mode. The OS
      cannot "attract" color generated by DLI's, although your DLI
      routine can, at a loss of time.

      Joysticks alone will not reset location 77 to zero. You will have to
      add a POKE 77,0 to your program periodically or frequently call
      in a subroutine to prevent the Atari from entering attract mode if
      you are not using any keyboard input.


 78              4E              DRKMSK

      Dark attract mask; set to 254 ($FE) for normal brightness when
      the attract mode is inactive (see location 77). Set to 246 ($F6)
      when the attract mode is active to guarantee screen color
      luminance will not exceed 50% . Initialized to 254 ($FE).


 79              4F              COLRSH

      Color shift mask; attract color shifter; the color registers are
      EORd with locations 78 and 79 at the stage two VBLANK (see
      locations 18 - 20; $12 - $14). When set to zero and location 78
      equals 246, color luminance is reduced 50%. COLRSH contains
      the current value of location 19, therefore is given a new color
      value every 4.27 seconds.

 Bytes 80 to 122 ($50 to $7A) are used by the screen editor and display
 handler.


 80              50              TEMP

      Temporary register used by the display handler in moving data to
      and from screen. Also called TMPCHR.


 81              51              HOLD1

      Same as location 80. It is used also to hold the number of Display
      List entries.


 82              52              LMARGN

      Column of the left margin of text (GR.0 or text window only).
      Zero is the value for the left edge of the screen; LMARGN is
      initialized to two. You can POKE the margin locations to set them
      to your specific program needs, such as POKE 82,10 to make the
      left margin start ten locations from the edge of the screen.


 83              53              RMARGN

      Right margin of the text screen initialized to 39 ($27). Both
      locations 82 and 83 are user-alterable, but ignored in all
      GRAPHICS modes except zero and the text window.
      Margins work with the text window and blackboard mode and are
      reset to their default values by pressing RESET. Margins have no
      effect on scrolling or the printer. However, DELETE LINE and
      INSERT LINE keys delete or insert 40 character lines (or delete
      one program line), which always start at the left margin and wrap
      around the screen edge back to the left margin again. The right
      margin is ignored in the process. Also, logical lines are always
      three physical lines no matter how long or short you make those
      lines.
      The beep you hear when you are coming to the end of the logical
      line works by screen position independent of the margins. Try
      setting your left margin at 25 (POKE 82,25) and typing a few lines
      of characters. Although you have just a few characters beyond
      60, the buzzer will still sound on the third line of text.


 84              54              ROWCRS

      Current graphics or text screen cursor row, value ranging from
      zero to 191 ($BF) depending on the current GRAPHICS mode
      (maximum number of rows, minus one). This location, together      
      with location 85 below, defines the cursor location for the next
      element to be read/written to the screen. Rows run horizontally,
      left to right across the TV screen. Row zero is the topmost line;
      row 192 is the maximum value for the bottom-most line.


 85,86           55,56           COLCRS

      Current graphics or text mode cursor column; values range from
      zero to 319 (high byte, for screen mode eight) depending on
      current GRAPHICS mode (maximum numher of columns minus
      one). Location 86 will always be zero in modes zero through
      seven. Home position is 0,0 (upper left-hand corner). Columns
      run vertically from the top to the bottom down the TV screen, the
      leftmost column being number zero, the rightmost column the
      maximum value in that mode. The cursor has a complete top to
      bottom, left to right wraparound on the screen.

      ROWCRS and COLCRS define the cursor location for the next
      element to be read from or written to in the main screen segment
      of the display. For the text window cursor, values in locations 656
      to 667 ($290 to $29B) are exchanged with the current values in
      locations 84 to 95 ($54 to $5F), and location 123 ($7B) is set to 255
      ($FF) to indicate the swap has taken place. ROWCRS and
      COLCRS are also used in the DRAW and FILL functions to
      contain the values of the endpoint of the line being drawn. The
      color of the line is kept in location 763 ($2FB). These values are
      loaded into locations 96 to 98 ($60 to $62) so that ROWCRS and
      COLCRS may be altered during the operation.

      BASIC's LOCATE statement not only examines the screen, but
      also moves the cursor one position to the right at the next PRINT
      or PUT statement. It does this by updating locations 84 and 85,
      above. You can override the cursor advance by saving the
      contents of the screen before the LOCATE command, then
      restoring them after the LOCATE. Try:

      100  REM: THE SCREEN MUST HAVE BEEN 0
          PENED FOR READ OR READ/WRITE PREV
          IOUSLY
      110  LOOK = PEEK(84): SEE = PEEK(85)
      120  LOCATE X,Y,THIS
      130  POKE 84, LOOK: POKE 65, SEE

      Note that CHR$(253) is a non-printing character---the bell--
      and doesn't affect the cursor position.

      See COMPUTE!, August 198l, for an example of using COLCRS
      for dynamic data restore and updating with the screen editor and
      the IOCBs.


 87              57              DINDEX

      Display mode/current screen mode. Labelled CRMODE by (*M).
      DINDEX contains the number obtained from the low order four
      bits of most recent open AUX1 byte. It can be used to fool the OS
      into thinking you are in a different GRAPHICS mode by
      POKEing DINDEX with a number from zero to 11. POKE with
      seven after you have entered GRAPHICS mode eight, and it will
      give you a split screen with mode seven on top and mode eight
      below. However, in order to use both halves of the screen, you
      will have to modify location 89 (below) to point to the area of the
      screen you wish to DRAW in. (See Your Atan 400/800, pp. 280 -
      283.)
      Watch for the cursor out-of-range errors (number 141) when
      changing GRAPHICS modes in this manner and either PRINTing
      or DRAWing to the new mode screen. POKE 87 with the BASIC
      mode number, not the ANTIC mode number.
      Did you know you can use PLOT and DRAWTO in GR.0? Try
      this:

      10   GR.0
      20   PLOT 0,0: DRAWTO 10,10: DRAWTO 0
         ,10
      30   DRAWTO 39,0: DRAWTO 20,23: DRAWT
         O 0,20
      40   GOTO 40

      You can also set the text window for PRINT and PLOT modes by
      POKEing 87 with the graphics mode for the window. Then you
      must POKE the address of the top left corner of the text window
      into 88 and 89 ($58, $59). The screen mode of the text window is
      stored at location 659 ($293).

      You may have already discovered that you cannot call up the
      GTIA modes from a direct command. Like the + 16 GRAPHICS
      modes, they can only be called up during a program, and the
      screen display will be reset to GR.0 on the first INPUT or PRINT
      (not PRINT#6) statement executed in these modes.

      Since this location only takes BASIC modes, you can't POKE it
      with the other ANTIC modes such as "E", the famous "seven-and-
      a-half" mode which offers higher resolution than seven and a four
      color display (used in Datasoft's Micropainter program). If you're
      not drawing to the screen, simply using it for display purposes,
      you can always go into the Display List and change the
      instructions there. But if you try to draw to the screen, you risk an
      out-of-bounds error (error number 141).

      See Creative Computing, March 1982, for an excellent look at
      mode 7.5. The short subroutine below can be used to change the
      Display List to GR.7.5:

      1000  GRAPHICS 8+16: DLIST = PEEK(560)
           ) + PEEK(561) * 256:POKE DLIST +
            3,78
      1010  FOR CHANGE = DLIST + 6 TO DLIST
            + 204: IF PEEK(CHANGE) = 15 THE
           N POKE CHANGE,14
      1020  IF PEEK (CHANGE) = 79 THEN POKE
           CHANGE,78: NEXT CHANGE
      1030  POKE 87,7:RETURN
     
      DOWNLOAD MODE75.BAS

      (Actually, 15 ($F) is the DL number for the maximum memory
      mode; it also indicates modes eight through eleven. The DL's for
      these modes are identical.) Fourteen is the ANTIC E mode;
      GR.7.5 This program merely changes GR.8 to mode E in the
      Display List. The value 79 is 64 + 15; mode eight screen with BIT
      6 set for a Load Memory Scan (LMS) instruction (see the DL
      information in locations 560, 561; $230, $231). It does not check
      for other DL bits.

      You can also POKE 87 with the GTIA values (nine to eleven). To
      get a pseudo-text window in GTIA modes, POKE the mode
      number here and then POKE 623 with 64 for mode nine, 128 for
      mode ten, and 192 for mode eleven, then POKE 703 with four, in
      program mode. (In command mode, you will be returned to
      GR.0.) You won't be able to read the text in the window, but you
      will be able to write to it. However, to get a true text window,
      you'll need to use a Display List Interrupt (see COMPUTE!,
      September 1982). If you don't have the GTIA chip, it is still
      possible to simulate those GRAPHICS modes by using DINDEX
      with changes to the Display List Interrupt. See COMPUTE!, July
      1981, for an example of simulating GR.10.


 88,89           58,59           SAVMSC

      The lowest address of the screen memory, corresponding to the
      upper left corner of the screen (where the value at this address
      will be displayed). The upper left corner of the text window is
      stored at locations 660, 661 ($294, $295).
      You can verify this for yourself by:

      WINDOW = PEEK(88) + PEEK(89) * 256: POKE WINDOW,33

      This will put the letter "A" in the upper left corner in GR.0, 1 and
      2. In other GRAPHICS modes, it will print a colored block or
      bar. To see this effect, try:

      5   REM FIRST CLEAR SCREEN
      10  GRAPHICS Z: IF Z > 59 THEN END
      15  SCREEN = PEEK (88) + PEEK (89) *
         256
      20  FOR N = 0 TO 255: POKE SCREEN + N
         ,N
      25  NEXT N: FOR N = 1 TO 300: NEXT N:
           Z = Z + 1
      30  GOTO 10
     
      DOWNLOAD SAVEMSC1.BAS

      You will notice that you get the Atari internal character code, not
      the ATASCII code. See also locations 560, 561 ($230, $231) and
      57344 ($E000).

      How do you find the entire screen RAM? First, look at the chart
      below and find your GRAPHICS mode. Then you multiply the
      number of rows-per-screen type by the number of bytes-per-line.
      This will tell you how many bytes each screen uses. Add this
      value, minus one, to the address specified by SAVMSC.
      However, if you subtract MEMTOP (locations 741, 742; $2E5,
      $2E6) from RAMTOP (106; $6A * 256 for the number of bytes),
      you will see that there is more memory reserved than just the
      screen area. The extra is taken up by the display list or the text
      window, or is simply not used (see the second chart below).

      Mode          0    1    2    3    4    5    6    7    8 9-12

      Rows
      Full         24   24   12   24   48   48   96   96  192  192
      Split        --   20   10   20   40   40   80   80  160  --

      Bytes per
      Line         40   20   20   10   10   20   20   40   40   40

      Columns
      per Line     40   20   20   40   80   80  160  160  320   80

      Memory (1)  993  513  261  273  537 1017 2025 3945 7900 7900

      Memory (2)
      Full        992  672  420  432  696 1176 2184 4200 8138 8138
      Split        --  674  424  434  694 1174 2174 4190 8112  --

      (1) According to the Atari BASIC Reference Manual, p.45; OS
      User's Manual, p.172, and Your Atari 400/800, p.360.

      (2) According to Your Atari 400/800, p.274, and Atari Microsoft
      Basic Manual, p.69. This is also the value you get when you
      subtract MEMTOP from RAMTOP (see above).

      For example, to POKE the entire screen RAM in GR.4, you
      would find the start address of the screen (PEEK(88) + PEEK(89)
      * 256), then use a FOR-NEXT loop to POKE all the locations
      specified above:

      10   GRAPHICS 4: SCRN = PEEK(88) + PE
         EK(89) * 256
      20   FOR LOOP = SCRN to SCRN + 479: R
         EM 48 ROWS * 10 BYTES - 1
      30   POKE LOOP,35: NEXT LOOP
     
      DOWNLOAD SAVEMSC2.BAS

      Why the minus one in the calculation? The first byte of the screen
      is the first byte in the loop. If we add the total size, we will go one
      byte past the end of the soreen, so we subtract one from the total.
      Here's how to arrive at the value for the total amount ot memory
      located for screen use, display list and Text window:

                Total memory allocation for the screen

                       Screen display       Display List
      -----------------------------------------------------------
           Text    unused  bytes  screen    unused  used
      GR  window   always  cond.   use      bytes   bytes   Total
      -----------------------------------------------------------
      0    ...      none   none    960      none      32      992
      1    160      none     80    400      none      34      674
      2    160      none     40    200      none      24      424
      3    160      none     40    200      none      34      434
      4    160      none     80    400      none      54      694
      5    160      none    160    800      none      54     1174
      6    160      none    320   1600      none      94     2174
      7    160      none    640   3200        96      94     4190
      8    160        16   1280   6400        80     176     8112

      The number of bytes from RAMTOP (location 106; $6A) is counted
      from the left text window column towards the total column.
      MEMTOP (741, 742; $2E5, $2E6) points to one byte below
      RAMTOP * 256 minus the number of bytes in the total column. If
      16 is added to the GRAPHICS mode (no text window), then the
      conditional unused bytes are added to the total. Then the bytes
      normally added for the text window become unused, and the
      Display List expands slightly. (See COMPUTE!, September 1981.)

      When you normally PRINT CHR$(125) (clear screen), Atari sends
      zeroes to the memory starting at locations 88 and 89. It continues to
      do this until it reaches one byte less than the contents of RAMTQP
      (location 106; $6A). Here is a potential source of conflict with your
      program, however: CHR$(125)--CLEAR SCREEN--and any
      GRAPHICS command actually continue to clear the first 64 ($40)
      bytes above RAMTOP!

      It would have no effect on BASIC since BASIC is a ROM
      cartridge. The OS Source Listing seems to indicate that it ends at
      RAMTOP, but Atari assumed that there would be nothing after
      RAMTOP, so no checks were provided. Don't reserve any data
      within 64 bytes of RAMTOP or else it will be eaten by the CLEAR
      SCREEN routine, or avoid using a CLEAR SCREEN or a
      GRAPHICS command. Scrolling the text window also clears 800
      bytes of memory above RAMTOP.

      You can use this to clear other areas of memory by POKEing the
      LSB and MSB of the area to be cleared into these locations. Your
      routine should always end on a $FF boundary (RAMTOP indicates
      the number of pages). Remember to POKE back the proper screen
      locations or use a GRAPHICS command immediately after doing
      so to set the screen right. Try this:

      10  BOTTOM = 30000: TOP = 36863: REM
         LOWEST AND HIGHEST ADDRESS TO CLEA
         R = $7530 & $8FFF
      20  RAMTOP = PEEK(106): POKE 106, INT
         (TOP + 1 / 256)
      30  TEST = INT(BOTTOM / 256): POKE89,
          TEST
      40  POKE 88. BOTTOM - 256 * TEST
      50  PRINT CHR$(125): POKE 106, RAMTOP
      60  GRAPHICS 0
     
      DOWNLOAD SAVEMSC3.BAS

      This will clear the specified memory area and update the address
      of screen memory. If you don't specify TOP, the CLEAR SCREEN
      will continue merrily cleaning out memory and, most likely, will
      cause your program to crash. Use it with caution.
      Here's a means to SAVE your current GR.7 screen display to disk
      using BASIC:

      1000  SCREEN = PEEK(88) + PEEK(89) *
           256
      1010  OPEN #2,8,0,"D:picturename"
      1020  MODE = PEEK(87): PUT #2, MODE:
           REM SAVE GR. MODE
      1030  FOR SCN = 0 TO 4: COL PEEK(70
           8 + SCN): PUT #2,COL: NEXT SCN:
           REM SAVE COLOR REGISTERS
      1040  FOR TV = SCREEN TO SCREEN + 319
           9:BYTE = PEEK(TV): PUT #2, BYTE:
           NEXT TV: CLOSE #2
          
      DOWNLOAD SAVEMSC4.BAS

      To use this with other screen modes, you will have to change the
      value of 3199 in line 1040 to suit your screen RAM (see the chart
      above). For example, GR.7 + 16 would require 3839 bytes (3840
      minus one). You can use the same routine with cassette by using
      device C:. To retrieve your picture, you use GET#2 and POKE
      commands. You will, however, find both routines very slow. Using
      THE CIO routine at 58454 ($E456) and the IOCBs, try this machine
      language save routine:

      10  DIM ML$(10): B$(10): GR.8+16
      20  B$ = "your picture name":Q = PEEK
         (559)
      30  FOR N = 1 TO 6: READ BYTE: ML$(N,
         N) = CHR$(BYTE): NEXT N
      35  DATA 104,162,16,76,86,228
      36  REM PLA,LDX,$10,JMP $E456
      40  OPEN #1,4,0,B$
      50  POKE 849,1: POKE 850,7: POKE 852,
         PEEK(88): POKE 853,PEEK(89): POKE
         856,70: POKE 857,30: POKE 858,4
      55  REM THESE POKES SET UP THE IOCB
      60  POKE 559,0: REM TURN OFF THE SCRE
         EN TO SPEED THINGS UP
      70  X = USR(ADR(ML$)): CLOSE #1
      80  POKE 559,Q: REM TURN IT BACK ON A
         GAIN
        
      DOWNLOAD SAVEMSC5.BAS

      Note that there is no provision to SAVE the color registers in this
      program, so I suggest you have them SAVEd after you have
      SAVEd the picture. It will make it easier to retrieve them if they are
      at the end of the file. You will have to make suitable adjustments
      when SAVEing a picture in other than GR.8 + 16 -- such as
      changing the total amount of screen memory to be SAVEd, POKEd
      into 856 and 857. Also, you will need a line such as 1000 GOTO
      1000 to keep a GTIA or + 16 mode screen intact. See the Atari
      column in InfoAge Magazine, July 1982, for more on this idea. See
      location 54277 ($D405) for some ideas on scrolling the screen
      RAM.

 ------------------------------------------------------------------------
 A SHORT DIGRESSION
 There are two techniques used in this hook for calling a machine
 language program from BASIC with the USR command. One method
 is to POKE the values into a specific address -- say, page six -- and
 use the starting address for the USR call, such as X = USR(1536). For
 an example of this technique, see location 632 ($278).

 The other technique, used above, is to make a string (ML$) out of the
 routine by assigning to the elements of the string the decimal
 equivalents of the machine language code by using a FOR-NEXT and
 READ-DATA loop. To call this routine, you would use X =
 USR(ADR(ML$)). This tells the Atari to call the machine language
 routine located at the address where ML$ is stored. This address will
 change with program size and memory use. The string method won't
 be overwritten by another routine or data since it floats around safely
 in memory. The address of the string itself is stored by the string/array
 table at location 140 ($8C).
 ------------------------------------------------------------------------


 90              5A              OLDROW

      Previous graphics cursor row. Updated from location 84 ($54)
      before every operation. Used to determine the starting row for
      the DRAWTO and XIO 18 (FILL command).


 91,92           5B,5C           OLDCOL

      Previous graphics cursor column. Updated from locations 85 and
      86 ($55, $56) before every operation. These locations are used by
      the DRAWTO and XIO 18 (FILL) commands to determine the
      starting column of the DRAW or FILL


 93              5D              OLDCHR

      Retains the value of the character under the cursor used to
      restore that character when the cursor moves


 94,95           5E,5F           OLDADR

      Retains the memory location of the current cursor location. Used
      with location 93 (above) to restore the character under the cursor
      when the cursor moves


 96              60              NEWROW

      Point (row) to which DRAWTO and XIO 18 (FILL) will go.


 97,98           61,62           NEWCOL

      Point (column) to which DRAWTO and XIO 18 (FILL) will go.
      NEWROW and NEWCOL are initialized to the values in
      ROWCRS and COLCRS (84 to 86; $54 to $56) above, which
      represent the destination end point of the DRAW and FILL
      functions. This is done so that ROWCRS and COLCRS can be
      altered during these routines.


 99              63              LOGCOL

      Position of the cursor at the column in a logical line. A logical
      line can contain up to three physical lines, so LOGCOL can
      range between zero and 119. Used by the display handler.
  

 100,101                 64,65           ADRESS

      Temporary storage used by the display handler for the Display
      List address, line buffer (583 to 622; $247 to $26E), new MEMTOP
      value after DL entry, row column address, DMASK value, data to
      the right of cursor, scroll, delete, the clear screen routine and for
      the screen address memory (locations 88, 89; $58, $59).


 102,103                 66,67           MLTTMP

      Also called OPNTMP and TOADR; first byte used in OPEN as
      temporary storage. Also used by the display handler as
      temporary storage.


 104,105                 68,69           SAVADR

      Also called FRMADR. Temporary storage, used with ADRESS
      above for the data under the cursor and in moving line data on
      the screen.


 106             6A              RAMTOP

      RAM size, defined by powerup as passed from TRAMSZ (location
      6), given in the total number of available pages (one page equals
      256 bytes, so PEEK(106) * 256 will tell you where the Atari thinks
      the last usable address --byte-- of RAM is). MEMIOP (741,
      742; $2E5. $2E6) may not extend below this value. In a 48K Atari,
      RAMTOP is initialized to 160 ($A0), which points to location
      40960 ($A000). The user's highest address will be one byte less
      than this value.

      This is initially the same value as in location 740. PEEK(740) / 4 or
      PEEK(106) / 4 gives the number of 1K blocks. You can fool the
      computer into thinking you have less memory than you actually
      have, thus reserving a relatively safe area for data (for your new
      character set or player/missile characters, for example) or
      machine language subroutines by:

      POKE(106), PEEK(106) - # of pages you want to reserve.

      The value here is the number of memory pages (256-byte blocks)
      present. This is useful to know when changing GR.7 and GR.8
      screen RAM. If you are reserving memory for PM graphics,
      POKE 54279, PEEK(106) - # of pages you are reserving before
      you actually POKE 106 with that value. To test to see if you have
      exceeded your memory by reserving too much memory space,
      you can use:

      10   SIZE = (PEEK(106) - # of pages)
         * 256
      20   IF SIZE < = PEEK(144) + PEEK(145
         ) * 256 THEN PRINT "TOO MUCH MEMOR
         Y USED"

      If you move RAMTOP to reserve memory, always issue a
      GRAPHICS command (even issuing one to the same GRAPHICS
      mode you are in will work) immediately so that the display list
      and data are moved beneath the new RAMTOP.

      You should note that a GRAPHICS command and a CLEAR
      command (or PRINT CHR$(125)) actually clear the first 64 bytes
      above RAMTOP (see location 88; $58 for further discussion).
      Scrolling the text window of a GRAPHICS mode clears up to 800
      ($320) bytes above RAMTOP (the text window scroll actually
      scrolls an entire GR.0 screen-worth of data, so the unseen 20
      lines * 40 bytes equals 800 bytes). PM graphics may be safe
      (unless you scroll the text window) since the first 384 or 768 bytes
      (double or single line resolution, respectively) are unused.
      However, you should take both of these effects into account when
      writing your programs.
      To discover the exact end of memory, use this routine (it's a tad
      slow):

      10  RAMTOP = 106: TOP = PEEK(RAMTOP)
      20  BYTE = TOP * 256: TEST = 255 - PE
         EK(BYTE): POKE BYTE,TEST
      30  IF PEEK(BYTE) = TEST THEN TOP = T
          OP +1: POKE BYTE, 255 - TEST
      40  GOTO 20
      50  PRINT "MEMORY ENDS AT "; BYTE

      One caution: BASIC cannot always handle setting up a display
      list and display memory for GRAPHICS 7 and GRAPHICS 8
      when you modify this location by less than 4K (16 pages; 4096
      bytes). Some bizarre results may occur if you use PEEK(106) - 8
      in these modes, for example. Use a minimum of 4K (PEEK(106) -
      16) to avoid trouble. This may explain why some people have
      difficulties with player/missile graphics in the hi-res (high
      resolution; GR.7 and GR.8) modes. See location 54279 ($D407).

      Another alternative to reserving memory in high RAM is to save
      an area below MEMLO, location 743 ($2E7: below your BASIC
      program). See also MEMTOP, locations 741, 742 ($2E5, $2E6).


 107             6B              BUFCNT

      Buffer count: the screen editor current logical line size counter.


 108,109                 6C,6D           BUFSTR

      Editor low byte (AM). Display editor GETCH routine pointer
      (location 62867 for entry; $F593). Temporary storage; returns the
      character pointed to by BUFCNT above.


 110             6E              BITMSK

      Bit mask used in bit mapping routines by the OS display handler
      at locations 64235 to 64305 ($FAEB to $FB31). Also used as a
      display handler temporary storage register.


 111             6F              SHFAMT

      Pixel justification: the amount to shift the right justified pixel data
      on output or the amount to shift the input data to right justify it.
      Prior to the justification process, this value is always the same as
      that in 672 ($2A0).


 112,113                 70,71           ROWAC

      ROWAC and COLAC (below) are both working accumulators for
      the control of row and column point plotting and the increment
      and decrement functions.


 114,115                 72,73           COLAC

      Controls column point plotting.


 116,117                 74,75           ENDPT

      End point of the line to be drawn. Contains the larger value of
      either DELTAR or DELTAC (locations 118 and 119, below) to be
      used in conjunction with ROWAC/COLAC (locations 112 and
      114, above) to control the plotting of line points.


 118             76              DELTAR

      Delta row; contains the absolute value of NEWBOW (location 96;
      $60) minus ROWCRS (location 84; $54).


 119,120                 77,78           DELTAC

      Delta column; contains the absolute value of NEWCOL (location
      97; $61) minus the value in COLCRS (location 85; $55). These
      delta register values, along with locations 121 and 122 below, are
      used to define the slope of the line to be drawn.


 121             79              ROWINC

      The row increment or decrement value (plus or minus one).


 122             7A              COLINC

      The column increment or decrement value (plus or minus one).
      ROWINC and COLINC control the direction of the line drawing
      routine. The values represent the signs derived from the value in
      NEWROW (location 96; $60) minus the value in ROWCRS
      (location 84; $54) and the value in NEWCOL (locations 97, 98;
      $61, $62) minus the value in COLCRS (locations 85, 86; $55,
      $56).


 123             7B              SWPFLG

      Split-screen cursor control. Equal to 255 ($FF) if the text window
      RAM and regular RAM are swapped; otherwise, it is equal to
      zero. In split-screen modes, the graphics cursor data and the text
      window data are frequently swapped in order to get the values
      associated with the area being accessed into the OS data base
      locations 84 to 95 ($54 to $5F). SWPFLG helps to keep track of
      which data set is in these locations.


 124             7C              HOLDCH

      A character value is moved here before the control and shift logic
      are processed for it.


 125             7D              INSDAT

      Temporary storage byte used by the display handler for the
      character under the cursor and end of line detection.


 126,127                 7E,7F           COUNTR

      Starts out containing the larger value of either DELTAR (location
      118; $76) or DELTAC (location 119; $77). This is the number of
      iterations required to draw a line. As each point on a line is
      drawn, this value is decremented. When the byte equals zero, the
      line is complete (drawn).

 ---------------------------------------------------------------------

 User and/or BASIC page zero RAM begins here. Locations 128 to 145
 ($80 to $91) are for BASIC program pointers; 146 to 202 ($92 to $CA)
 are for miscellaneous BASIC RAM; 203 to 209 ($CB to $D1) are
 unused by BASIC, and 210 to 255 ($D2 to $FF) are the floating point
 routine work area. The Assembler Editor cartridge uses locations 128
 to 176 ($80 to $B0) for its page zero RAM. Since the OS doesn't use this
 area, you are free to use it in any non-BASIC or non-cartridge
 environment. If you are using another language such as FORTH,
 check that program's memory map to see if any conflict will occur.
 See COMPUTE!'s First Book of Atari, pages 26 to 53, for a discussion
 of Atari BASIC structure, especially that using locations 130 to 137
 ($82 to $89). Included in the tutorials are a memory analysis, a line
 dump, and a renumber utility. See also De Re Atari, BYTE, February
 1982, and the locations for the BASIC ROM 40960 to 49151 ($A000 to
 $BFFF).


 128,129                 80,81           LOMEM

      Pointer to BASIC's low memory (at the high end of OS RAM
      space). The first 256 bytes of the memory pointed to are the token
      output buffer, which is used by BASIC to convert BASIC
      statements into numeric representation (tokens; see locations
      136, 137; $88, $89). This value is loaded from MEMLO (locations
      743, 744; $2E7, $2E8) on initialization or the execution of a NEW
      command (not on RESET!). Remember to update this value when
      changing MEMLO to reserve space for drivers or buffers.
      When a BASIC SAVE is made, two blocks of information are
      written: the first block is the seven pointers from LOMEM to
      STARP (128 to 141; $80 to $8D). The value of LOMEM is
      subtracted from each of these two-byte pointers in the process, so
      the first two bytes written will both be zero. The second block
      contains the following: the variable name table, the variable
      value table, the tokenized program, and the immediate mode
      line.
      When a BASIC LOAD is made, BASIC adds the value at MEMLO
      (743, 744; $2E7, $2E8) to each of the two-byte pointers SAVEd as
      above. The pointers are placed back in page zero, and the values
      of RUNSTK (142, 143; $8E, $8F) and MEMTOP (144, 145; $90,
      $91) are set to the value in STARP. Then 256 bytes are reserved
      above the value in MEMLO for the token output buffer, and the
      program is read in immediately following this buffer.
      When you don't have DOS or any other application program
      using low memory loaded, LOMEM points to 1792 ($700). When
      DOS 2.0 is present, it points to 7420 ($1CFC). When you change
      your drive and data buffer defaults (see 1801, 1802; $709, $70A),
      you will raise or lower this figure by 128 bytes for each buffer
      added or deleted, respectively. When you boot up the RS-232
      handler, add another 1728 ($6C0) bytes used.
      LOMEM is also called ARGOPS by BASIC when used in
      expression evaluation. When BASIC encounters any kind of
      expression, it puts the immediate results into a stack. ARGOPS
      points to the same 256 byte area; for this operation it is reserved
      for both the argument and operator stack. It is also called
      OUTBUFF for another operation, pointing to the same 256 byte
      buffer as ARGOPS points to. Used by BASIC when checking a
      line for syntax and converting it to tokens. This buffer
      temporarily stores the tokens before moving them to the
      program.


 130,131                 82,83           VNTP

      Beginning address of the variable name table. Variable names
      are stored in the order input into your program, in ATASCII
      format. You can have up to 128 variable names. These are stored
      as tokens representing the variable number in the tokenized
      BASIC program, numbered from 128 to 255 ($80 to $FF).

      The table continues to store variable names, even those no longer
      used in your program and those used in direct mode entry. It is
      not cleared by SAVEing your program. LOADing a new program
      replaces the current VNT with the one it retrieves from the file.
      You must LIST the program to tape or disk to save your program
      without these unwanted variables from the table. LIST does not
      SAVE the variable name or variable value tables with your
      program. It stores the program in ATASCII, not tokenized form,
      and requires an ENTER command to retrieve it. You would use a
      NEW statement to clear the VNT in memory once you have
      LISTed your program.

      Each variable name is stored in the order it was entered, not the
      ATASCII order. With numeric (scalar) variables, the MSB is set
      on the last character in a name. With string variables, the last
      character is a "$" with the MSB (BIT 7) set. With array variables,
      the last character is a "(" with the MSB set. Setting the MSB turns
      the character into its inverse representation so it can be easily
      recognized.
      You can use variable names for GOSUB and GOTO routines,
      such as:

      10  CALCULATE = 1000
      .
      .
      100  GOSUB CALCULATE

      This can save a lot of bytes for a frequently called routine. But
      remember, each variable used for a GOSUB or GOTO address
      uses one of the 128 possible variable names. A disadvantage of
      using variable names for GOTO and GOSUB references is when
      you try to use a line renumbering program. Line renumbering
      programs will not change references to lines with variable
      names, only to lines with numbered references.

      Here's a small routine you can add to the start of your BASIC
      program (or the end if you change the line numbers) to print out
      the variable names used in your program. You call it up with a
      GOTO statement in direct mode:

      1   POKE 1664, PEEK(130): POKE 1665,
         PEEK (131)
      2   IF PEEK(1664) = PEEK(132) THEN IF
         PEEK(1665) = PEEK(133) THEN STOP
      3   PRINT CHR$(PEEK(PEEK(1664) + PEEK
        (1665) * 256)));
      4   IF PEEK(PEEK(1664) + PEEK(1665) *
         256)) > 127 THEN PRINT"";
      5   IF PEEK(1664) = 255 THEN POKE 166
        4, 0: POKE 1665, PEEK(1665) + 1: GO
        TO 2
      6   POKE 1664, PEEK(1664) + 1: GOTO 2
     
      DOWNLOAD VNTP.BAS

      See COMPUTE!, October 1981.


 132,133                 84,85           VNTD

      Pointer to the ending address of the variable name table plus one
      byte. When fewer than 128 variables are present, it points to a
      dummy zero byte. When 128 variables are present, this points to
      the last byte of the last variable name, plus one.

      It is often useful to be able to list your program variables; using
      locations 130 to 133, you can do that by:

      10   VARI = PEEK(130) + PEEK(131) * 2
         56 :REM This gives you the start o
         f the table.
      20   FOR VARI = VARI TO PEEK(132) + P
         EEK(133) * 256 - 1: PRINT CHR$(PEE
         K(VARI) - 128 * PEEK(VARI > 127));
          CHR$(27 + 128 * PEEK(VARI) > 127)
         );:NEXT VARI
      25   REM this finds the end of the va
         ri able name table (remember table
         is end + 1). then PRINTs ASCII cha
         racters < 128
      30   NUM = 0: FOR VARI = PEEK(130) +
         PEEK(313) * 256 TO PEEK(132) + PEE
         K(131) * 256 - 1:NUM = NUM + (PEEK
         (VARI) < 127):NEXT VARI: PRINT NU
         M; "Variables in use"
        
      DOWNLOAD VNTD1.BAS

 Or try this, for a possibly less opaque example of the same
 routine:

      1000  NUM = 0: FOR LOOP = PEEK (130) +
            PEEK(131) * 256 TO PEEK(132) +
            PEEK(133) * 256 - 1
      1010  IF PEEK(LOOP) < 128 THEN PRINT
           CHR$(PEEK(LOOP));: GOTO 1030
      1020  PRINT CHR$(PEEK(LOOP) - 128): N
           UM - NUM + 1
      1030  NEXT LOOP: PRINT; PRINT NUM; "
           VARIABLES IN USE": END
          
      DOWNLOAD VNTD2.BAS


 134,135                 86,87           VVTP

      Address for the variable value table. Eight bytes are allocated for
      each variable in the name table as follows:

      Byte              1         2     3  4     5     6    7      8
      Variable
      --------------------------------------------------------------
      Scalar           00     var #     six byte BCD constant
      Array;DIMed      65     var #     offset     first     second
          unDIMed      64               from       DIM + 1   DIM + 1
                                        STARP
      String;DIMed    129     var #     offset     length    DIM
           unDIMed    128               from
                                        STARP

      In scalar (undimensioned numeric) variables, bytes three to eight
      are the FP number; byte three is the exponent; byte four contains
      the least significant two decimal digits, and byte eight contains
      the most significant two decimal digits.
      In array variables, bytes five and six contain the size plus one of
      the first dimension of the array (DIM + 1; LSB/MSB), and bytes
      seven and eight contain the size plus one of the second dimension
      (the second DIM + 1; LSB/MSB).
      In string variables, bytes five and six contain the current length
      of the variable (LSB MSB), and bytes seven and eight contain the
      actual dimension (up to 32767). There is an undocumented
      BASIC statement, "COM," mentioned only in the BASIC
      Reference Manual's index, which executes exactly the same as
      the "DIM" statement (see Your Atari 400/800, p.346). Originally,
      it was to be used to implement "common" variables.

      In all cases, the first byte is always one of the number listed on the
      chart above (you will seldom, if ever, see the undimensioned
      values in a program). This number defines what type of variable
      information will follow. The next byte, var # (variable number), is
      in the range from zero to 127. Offset is the number of bytes from
      the beginning of STARP at locations 140 and 141 ($8C, $8D).
      Since each variable is assigned eight bytes, you could find the
      values for each variable by:

      1000  VVTP = PEEK(134) + PEEK(135) *
           256: INPUT VAR: REM VARIABLE NUM
           BER
      1010  FOR LOOP = 0 TO 7: PRINT PEEK(V
           VTP + LOOP + 8 * VAR): NEXT LOOP

      where VAR is the variable number from zero to 127.
      If you wish to assign the same value to every element in a DIMed
      string variable use this simple technique:

      10   DIM TEST$(100)
      20   TEST$ = "*": REM or use TEST$(1)
      30   TEST$(100) = TEST$
      40   TEST$(2) = TEST$: PRINT TEST$

      By assigning the first, last and second variables in the array in
      that order, your Atari will then assign the same value to the rest of
      the array. Make sure you make the second and last elements
      equal to the string, not the character value (i.e don't use
      TEXT$(2) = "*").
      See De Re Atari for an example of SAVEing the six-byte BCD
      numbers to a disk file -- very useful when dealing with fixed
      record lengths.


 136,137                 88,89           STMTAB

      The address of the statement table (which is the beginning of the
      user's BASIC program), containing all the tokenized lines of
      code plus the immediate mode lines entered by the user. Line
      numbers are stored as two-byte integers, and immediate mode
      lines are given the default value of line 32768 ($8000). The first
      two bytes of a tokenized line are the line number, and the next is
      a dummy byte reserved for the byte count (or offset) from the start
      of this line to the start of the next line.

      Following that is another count byte for the start of this line to the
      start of the next statement. These count values are set only when
      tokenization for the line and statement are complete.
      Tokenization takes place in a 256 byte ($100) buffer that resides at
      the end of the reserved OS RAM (pointed to by locations 128,
      129; $80, $81).
      To see the starting address of your BASIC line numbers use this
      routine:

      10   STMTAB = PEEK(136) + PEEK(137)*2
         56
      20   NUM = PEEK(STMTAB) + PEEK (STMTAB
         +1)*256
      30   IF NUM = 32768 THEN END
      40   PRINT"LINE NUMBER: ";NUM;" ADDRE
         SS: ";STMTAB
      50   STMTAB = STMTAB + PEEK(STMTAB+2)
      60   GOTO 20

      The August 1982 issue of ANTIC provided a useful program to
      delete a range of BASIC line numbers. The routine can be
      appended to your program and even be used to delete itself.


 138,139                 8A,8B           STMCUR

      Current BASIC statement pointer, used to access the tokens
      being currently processed within a line of the statement table.
      When BASIC is awaiting input, this pointer is set to the
      beginning of the immediate mode (line 32768).

      Using the address of the variable name table, the length, and the
      current statement (locations 130 to 133, 138, 139), here is a way to
      protect your programs from being LISTed or LOADed: they can
      only be RUN! Remember, that restricts you too, so make sure you
      have SAVEd an unchanqed version before you do this:

      32000   FOR VARI = PEEK(130) + PEEK(1
            31) * 256 TO PEEK(132) + PEEK(1
            33) * 256:POKE VARI,155:NEXT VA
            RI
      32100   POKE PEEK(138) + PEEK(139) *
            256 + 2,0: SAVE "D:filename": N
            EW

      This will cause all variable names to be replaced with a RETURN
      character. Other characters may be used: simply change 155 for
      the appropriate ATASCII code for the character desired. Make
      sure that these are the last two lines of your program and that
      NEW is the last statement. CLOAD will not work, but a filename
      with C: will.


 140,141                 8C,8D           STARP

      The address for the string and array table and a pointer to the end
      of your BASIC program. Arrays are stored as six-byte binary
      coded decimal numbers (BCD) while string characters use one
      bye each. The address of the strings in the table are the same as
      those returned by the BASIC ADR function. Always use this
      function under program control, since the addresses in the table
      change according to your program size. Try:

      10   DIM A$(10),B$(10)
      20   A$ = "*": A$(10) = A$: A$(2) = A
         $
      30   B$ = "&": B$(10) = B$: B$(2) = B
         $
      40   PRINT ADR(A$), ADR(B$)
      50   PRINT PEEK(140) + PEEK(141) * 25
         6: REM ADDRESS OF A$
      60   PRINT PEEK(140) + PEEK(141) * 25
         6 + 10: REM ADRESS OF A$ + 10 BYTE
         S = ADDRESS OF B$

      This table is expanded as each dimension is processed by
      BASIC, reducing available memory. A ten-element numeric
      array will require 60 bytes for storage. An array variable such as
      DIM A(100) will cost the program 600 bytes (100 * six per
      dimensioned number equals 600). On the other hand, a string
      array such as DIM A$(100) will only cost 100 bytes! It would save
      a lot of memory to write your arrays as strings and retrieve the
      array values using the VAL statement. For example:

      10   DIM A$(10): A$ = "1234567890"
      20   PRINT VAL(A$)
      30   PRINT VAL(A$(4,4))
      40   PRINT VAL(A$(3,3))+VAL(A$(8,9))

      See COMPUTE!, June 1982, for a discussion of STARP and
      VVTP. See De Re Atari for a means to SAVE the string/array area
      with your program.


 142,143                 8E,8F           RUNSTK

      Address of the runtime stack which holds the GOSUB entries
      (four bytes each) and the FOR-NEXT entries (16 bytes each). The
      POP command in BASIC affects this stack, pulling entries off it
      one at a time for each POP executed. The stack expands and
      contracts as necessary while the program is running.

      Each GOSUB entry consists of four bytes in this order: a zero to
      indicate a GOSUB, a two-byte integer line number on which the
      call occurred, and an offset into that line so the RETURN can
      come back and execute the next statement.

      Each FOR-NEXT entry contains 16 bytes in this order: first, the
      limit the counter variable can reach; second, the step or counter
      increment. These two are allocated six bytes each in BCD format
      (12 bytes total). The 13th byte is the counter variable number with
      the MSB set; the 14th and 15th are the line number and the 16th is
      the line offset to the FOR statement.
      RUNSTK is also called ENDSTAR; it is used by BASIC to point to
      the end of the string/array space pointed to by STARR above.


 144,145                 90,91           MEMTOP

      Pointer to the top of BASIC memory, the end of the space the
      program takes up. There may still be space between this address
      and the display list, the size of which may be retrieved by the
      FRE(0) command (which actually subtracts the MEMTOP value
      that is at locations 741 and 742; $2E5, $2E6). Not to be confused
      with locations 741 and 742, which have the same name but are an
      OS variable. MEMTOP is also called TOPSTK; it points to the top
      of the stack space pointed to by RUNSTK above.

      When reserving memory using location 106 ($6A) and MEMTOP,
      here's a short error-trapping routine you can add:

      10   SIZE = (PEEK(106) - # of pages yo
         u are reserving) * 256
      20   IF SIZE < = PEEK(144) + PEEK(145
         ) * 256 THEN PRINT " PROGRAM TOO L
         ARGE": END

      Locations 146 to 202 ($92 to $CA) are reserved for use by the 8K
      BASIC ROM.
      Locations 176 to 207 ($B0 to $CF) are reserved by the Assembler
      Editor cartridge for the user's page zero use. The Assembler debug
      routine also reserves 30 bytes in page zero, scattered from location 164
      ($A4) to 255 ($FF), but they cannot be used outside the debug process.
      (See De Re Atari, Rev. 1, Appendix A for a list of these available
      bytes.)


 186,187                 BA,BB           STOPLN

      The line where a program was stopped either due to an error or
      the use of the BREAK key, or a STOP or a TRAP statement
      occurred. You can use PEEK (186) + PEEK (187) * 256 in a
      GOTO or GOSUB statement.


 195             C3              ERRSAVE

      The number of the error code that caused the stop or the TRAP.
      You can use this location in a program in a line such as:

      10 IF PEEK(195) <> 144 THEN 100


 201             C9              PTABW

      This location specifies the number of columns between TAB
      stops. The first tab will beat PEEK(201). The default is ten. This is
      the value between items separated in a PRINT statement by com-
      mas -- such as PRINT AS, LOOP, C(12) -- not by the TAB key
      spacing.
      The minimum number of spaces between TABS is three. If you
      POKE 201,2, it will be treated as four spaces, and POKE 201,1 is
      treated as three spaces. POKE 201,0 will cause the system to
      hang when it encounters a PRINT statement with commas. To
      change the TAB key settings, see TABMAP (locations 675 to 689;
      $2A3 - $2B1). PTABW is not reset to the default value by pressing
      RESET or changing GRAPHICS modes (unlike TABMAP).
      PTABW works in all GRAPHICS modes, not merely in text
      modes. The size of the spaces between items depends on the pixel
      size in the GRAPHICS mode in use. For example, in GR.0, each
      space is one character wide, while in GR.8 each space is one-half
      color clock (one dot) wide.


 203-207                 CB-CF           ....

      Unused by either the BASIC or the Assembler cartridges.


 208-209                 D0-D1           ....

      Unused by BASIC. The only time I have seen any of these unused
      locations in use is in COMPUTE! (March 1982 and October
      1981), when they were used for user sort routines, and in ANTIC
      (June 1982), where they were used as flags in a graphic
      demonstration. The bytes from 203 to 209 ($CB to $D1) are the
      only page zero bytes uncontestably left free by BASIC.


 210-211                 D2-D3           ....

      Reserved for BASIC or other cartridge use.

 Locations 212 to 255 ($D4 to $FF) are reserved for the floating point
 package use. The FP routines are in ROM, from locations 55296 to
 57393 ($D800 to $E031). These page zero locations may be used if the
 FP package is not called by the user's program. However, do not use
 any of these locations for an interrupt routine, since such routines
 might occur during an FP routine called by BASIC, causing the
 system to crash.

 Floating Point uses a six-byte precision. The first byte of the Binary
 Coded Decimal (BCD) number is the exponent (where if BIT 7 equals
 zero, then the number is positive; if one, then it is negative). The next
 five bytes are the mantissa. If only that were all there was to it. The
 BCD format is rather complex and is best explained in chapter eight of
 De Re Atari.


 212-217                 D4-D9           FR0

      Floating point register zero; holds a six-byte internal form of the
      FP number. The value at locations 212 and 213 are used to return
      a two-byte hexadecimal value in the range of zero to 65536
      ($FFFF) to the BASIC program (low byte in 212, high byte in
      213). The floating point package, if used, requires all locations
      from 212 to 255. All six bytes of FR0 can be used by a machine
      language routine, provided FR0 isn't used and no FP functions
      are used by that routine. To use 16 bit values in FP, you would
      place the two bytes of the number into the least two bytes of FR0
      (212, 213; $D4, $D5), and then do a JSR to $D9AA (55722), which
      will convert the integer to its FP representation, leaving the result
      in FR0. To reverse this operation, do a JSR to $D9D2 (55762).


 218-223                 DA-DF           FRE

      FP extra register (?)


 224-229                 E0-E5           FR1

      Floating point register one; holds a six-byte internal form of the
      FP number as does FR0. The FP package frequently transfers
      data between these two registers and uses both for two-number
      arithmetic operations.


 230-235                 E6-EB           FR2

      FP register two.


 236             EC              FRX

      FP spare register.


 237             ED              EEXP

      The value of E (the exponent).


 238             EE              NSIGN

      The sign of the FP number.


 239             EF              ESIGN

      The sign of the exponent.


 240             F0              FCHRFLG

      The first character flag.

 241            Fl             DIGRT
      The number of digits to the right of the decimal.


 242             F2              CIX

      Character (current input) index. Used as an offset to the input
      text buffer pointed to by INBUFF below.


 243,244                 F3,F4           INBUFF

      Input ASCII text buffer pointer; the user's program line input
      buffer, used in the translation of ATASCII code to FP values. The
      result output buffer is at locations 1408 to 1535 ($580 to $5FF).


 245,246                 F5,F6           ZTEMP1

      Temporary register.


 247,248                 F7,F8           ZTEMP4

      Temporary register.


 249,250                 F9,FA           ZTEMP3

      Temporary register.


 251             FB              RADFLG

      Also called DEGFLG. When set to zero, all of the trigonometric
      functions are performed in radians; when set to six, they are done
      in degrees. BASIC's NEW command and RESET both restore
      RADFLG to radians.


 252,253                 FC,FD           FLPTR

      Points to the user's FP number.


 254,255                 FE,FF           FPTR2

      Pointer to the user's second FP number to be used in an
      operation.

      End of the page zero RAM.

 ---------------------------------------------------------------------------

 PAGE ONE: THE STACK

 Locations 256 to 511 ($100 to $1FF) are the stack area for the OS, DOS
 and BASIC. This area is page one. Machine language JSR, PHA and
 interrupts all cause data to be written to page one, and RTS, PLA and
 RTI instructions all read data from page one. On powerup or RESET,
 the stack pointer is initialized to point to location 511 ($1FF). The stack
 then pushes downward with each entry to 256 ($100). In case of
 overflow, the stack will wrap around from 256 back to 511 again.

 ---------------------------------------------------------------------------

 PAGES TWO TO FOUR

 Locations 512 to 1151 ($200 to $47F) are used by the OS for working
 variables, tables and data buffers. In this area, locations 512 to 553
 ($200 to $229) are used for interrupt vectors, and locations 554 to 623
 ($22A to $26F) are for miscellaneous use. Much of pages two through
 five cannot be used except by the OS unless specifically noted. A
 number of bytes are marked as "spare", i.e., not in use currently. The
 status of these bytes may change with an Atari upgrade, so their use is
 not recommended.

 There are two types of interrupts: Non-Maskable Interrupts (NMI)
 processed by the ANTIC chip and Interrupt Requests (IRQ) processed
 by the POKEY and the PIA chips. NMI's are for the VBLANK interrupts
 (VBI's; 546 to 549, $222 to $225), display list interrupts (DLI) and
 RESET key interrupts. They initiate the stage one and stage two
 VBLANK procedures; usually vectored through an OS service routine,
 they can be vectored to point to a user routine. IRQ's are for the timer
 interrupts, peripheral and serial bus interrupts, BREAK and other key
 interrupts, and 6502 BRK instruction interrupts. They can usually be
 used to vector to user routines. See NMIST 54287 ($D40F) and IRQEN
 53774 ($D20E) for more information. NMI interrupt vectors are marked
 NMI; IRQ interrupt vectors are marked IRQ.
 Refer to the chart below location 534 for a list of the interrupt vectors in
 the new OS "B" version ROMs.


 512,513                 200,201                 VDSLST

      The vector for NMI Display List Interrupts (DLI): containing the
      address of the instructions to be executed during a DLI (DLI's are
      used to interrupt the processor flow for a few microseconds at the
      particular screen display line where the bit was set, allowing you
      to do another short routine such as music, changing graphics
      modes, etc.). The OS doesn't use DLI's; they must be user-
      enabled, written and vectored through here. The NMI status
      register at 54287 ($D40F) first tests to see if an interrupt was
      caused by a DLI and, if so, jumps through VDSLST to the routine
      written by the user. DLI's are disabled on powerup, but VBI's are
      enabled (see 546 to 549; $222 to $225).

      VDSLST is initialized to point to 59315 ($E7B3), which is merely
      an RTI instruction. To enable DLI's, you must first POKE 54286
      ($D40E) with 192 ($C0); otherwise, ANTIC will ignore your
      request. You then POKE 512 and 513 with the address (LSB/MSB)
      of the first assembly language routine to execute during the DLI.
      You must then set BIT 7 of the Display List instruction(s) where
      the DLI is to occur. You have only between 14 and 61 machine
      cycles available for your DLI, depending on your GRAPHICS
      mode. You must first push any 6502 registers onto the stack, and
      you must end your DLI with an RTI instruction. Because you are
      dealing with machine language for your DLI, you can POKE
      directly into the hardware registers you plan to change, rather
      than using the shadow registers that BASIC uses.

      There is, unfortunately, only one DLI vector address. If you use
      more than one DLI and they are to perform different activities,
      then changing the vectoring to point to a different routine must
      be done by the previous DLI's themselves.

      Another way to accomplish interrupts is during the VBLANK
      interval with a VBI. One small problem with using DLI's is that
      the keyboard "click" routine interferes with the DLI by throwing
      off the timing, since the click is provided by several calls to the
      WSYNC register at 54282 ($D40A). Chris Crawford discusses
      several solutions in De Re Atari, but the easiest of them is not to
      allow input from the keyboard! See Micro, December 1981,
      Creative Computing, July 1981 and December 1981.
      Here's a short example of a DLI. It will print the lower half of your
      text screen upside down:

      10   START = PEEK(560) + PEEK(561) *
         256: POKE START + 16,130
      20   PAGE = 1536: FOR PGM = PAGE TO P
         AGE + 7: READ BYTE: POKE PGM, BYTE
         : NEXT PGM
      30   DATA 72,169,4,141,1,212,104,64
      40   POKE 512,0: POKE 513,6: POKE 542
         86,192
      50   FOR TEST = 1 TO 240: PRINT"SEE "
         ;: NEXT TEST
      60   GOTO 60
     
      DOWNLOAD VDSLST.BAS

      Another example of a DLI changes the color of the bottom half of
      the screen. To use it, simply change the PAGE + 7 to PAGE + 10
      in the program above and replace line 30 with:

      30   DATA 72,169,222,141,10,212,141,2
         4,208,104,64

      Finally, delete lines 50 and 60. See also location 54282 ($D40A).


 514,515                 202,203                 VPRCED

      Serial (peripheral) proceed line vector, initialized to 59314
      ($E7B2), which is merely a PLA, RTI instruction sequence. It is
      used when an IRQ interrupt occurs due to the serial I/O bus
      proceed line which is available for peripheral use. According to
      De Re Atari, this interrupt is not used and points to a PLA, RTI
      instruction sequence. This interrupt is handled by the PIA chip
      and can be used to provide more control over external devices.
      See the OS Listing, page 33.


 516,517                 204,205                 VINTER

      Serial (peripheral) interrupt vector, initialized to 59314 ($E7B2).
      Used for the IRQ interrupt due to a serial bus I/O interrupt.
      According to De Re Atari, this interrupt is not used and points to
      a PLA, RTI sequence. This interrupt is processed by PIA. See the
      OS Listing, page 33.


 518,519                 206,207                 VBREAK

      Software break instruction vector for the 6502 BRK ($00)
      command (not the BREAK key, which is at location 17; $11),
      initialized to 59314 ($E7B2). This vector is normally used for
      setting break points in an assembly language debug operation.
      IRQ.


 520,521                 208,209                 VKEYBD

      POKEY keyboard interrupt vector, used for an interrupt
      generated when any keyboard key is pressed other than BREAK
      or the console buttons. Console buttons never generate an
      interrupt unless one is specifically user-written. VKEYBD can be
      used to process the key code before it undergoes conversion to
      ATASCII form. Initialized to 65470 ($FFBE) which is the OS
      keyboard IRQ routine.


 522,523                 20A,20B                 VSERIN

      POKEY serial I/O bus receive data ready interrupt vector,
      initialized to 60177 ($EB11), which is the OS code to place a byte
      from the serial input port into a buffer. Called INTRVEC by DOS,
      it is used as an interrupt vector location for an SIO patch. DOS
      changes this vector to 6691 ($1A23), the start of the DOS
      interrupt ready service routine. IRQ.


 524,525                 20C,20D                 VSEROR

      POKEY serial I/O transmit ready interrupt vector, initialized to
      60048 (EA90), which is the OS code to provide the next byte in a
      buffer to the serial output port. DOS changes this vector to 6630
      ($19E6), the start of the DOS output needed interrupt routine.
      IRQ.


 526,527                 20E,20F                 VSEROC

      POKEY serial bus transmit complete interrupt vector, initialized
      to 60113 ($EAD1), which sets a transmission done flag after the
      checksum byte is sent. IRQ.

      SIO uses the three last interrupts to control serial bus
      communication with the serial bus devices. During serial bus
      communication, all program execution is halted. The actual
      serial I/O is interrupt driven; POKEY waits and watches for a flag
      to be set when the requested I/O operation is completed. During
      this wait, POKEY is sending or receiving bits along the seriai
      bus. When the entire byte has been transmitted (or received), the
      output needed (VSEROR) or the input ready (VSERIN) IRQ is
      generated according to the direction of the data flow. This causes
      the next byte to be processed until the entire buffer has been sent
      or is full, and a flag for "transmission done" is set. At this point,
      SIO exits back to the calling routine. You can see that SIO wastes
      time waiting for POKEY to send or receive the information on the
      bus.


 528,529                 210,211                 VTIMR1

      POKEY timer one interrupt vector, initialized to 59314 ($E7B2),
      which is a PLA, RTI instruction sequence. Timer interrupts are
      established when the POKEY timer AUDF1 (53760; $D200)
      counts down to zero. Values in the AUDF registers are loaded
      into STIMER at 53769 ($D209). IRQ.


 530,531                 212,213                 VTIMR2

      POKEY timer two vector for AUDF2 (53762, $D202), initialized to
      59314 ($E7B2). IRQ.


 532,533                 214,215                 VTIMR4

      POKEY timer four vector for AUDF4 (53766, $D206), initialized
      to 59314 ($E7B2). This IRQ is only vectored in the "B" version of
      the OS ROMs.


 534,535                 216,217                 VIMIRQ

      The IRQ immediate vector (general). Initialized to 59126
      ($E6F6). JMP through here to determine cause of the IRQ
      interrupt. Note that with the new ("B") OS ROMs, there is a
      BREAK key interrupt vector at locations 566, 567 ($236, $237).
      See 53774 ($D20E) for more information on IRQ interrupts.

      The new "B" version OS ROMs change the vectors above as
      follows:

      VDSLST     59280 ($E790)
      VPRCED     59279 ($E78F)
      VINTER     59279 ($E78F)
      VBREAK     59279 ($E78F)
      VKEYBD     NO CHANGE
      VSERIN     60175 ($EB0F)
      VSEROR     NO CHANGE
      VSEROC     60111 ($EACF)
      VTIMR 1-4  59279 ($E78F)
      VIMIRQ     59142 ($E706)
      VVBLKI     59310 ($E7AE)
      VVBLKD     59653 ($E905)

 ---------------------------------------------------------------------------
 The locations from 536 to 558 ($218 to $22E) are used for the system
 software timers. Hardware timers are located in the POKEY chip and
 use the AUDF registers. These timers count backwards every 1/60
 second (stage one VBLANK) or 1/30 second (stage two VBLANK)
 interval until they reach zero. If the VBLANK process is disabled or
 intercepted, the timers will not be updated. See De Re Atari for
 information regarding setting these timers in an assembly routine
 using the SETVBV register (58460; $E45C). These locations are user-
 accessible and can be made to count time for music duration, game
 I/O, game clock and other functions.
 Software timers are used for durations greater than one VBLANK
 interval (1/60 second). For periods of shorter duration, use the
 hardware registers.


 536,537                 218,219                 CDTMV1

      System timer one value. Counts backwards from 255. This SIO
      timer is decremented every stage one VBLANK. When it reaches
      zero, it sets a flag to jump (JSR) through the address stored in
      locations 550, 551 ($226, $227). Only the realtime clock
      (locations 18-20; $12-14), timer one, and the attract mode
      register (77; $4D) are updated when the VBLANK routine is cut
      short because time-critical code (location 66; $42 set to non-zero
      for critical code) is executed by the OS. Since the OS uses timer
      one for its I/O routines and for timing serial bus operations
      (setting it to different values for timeout routines), you should use
      another timer to avoid conflicts or interference with the operation
      of the system.


 538,539                 21A,21B                 CDTMV2

      System timer two. Decremented at the stage two VBLANK. Can
      be decremented every stage one VBLANK, subject to critical
      section test as defined by setting of CRITIC flag (location 66;
      $42). This timer may miss (skip) a count when time-critical code
      (CRITIC equals non-zero) is being executed. It performs a JSR
      through location 552, 553 ($228, $229) when the value counts
      down to zero.


 540,541                 21C,21D                 CDTMV3

      System timer three. Same as 538. Timers three, four, and five are
      stopped when the OS sets the CRITIC flag to non-zero as well.
      The OS uses timer three to OPEN the cassette recorder and to set
      the length of time to read and write tape headers. Any prior value
      in the register during this function will be lost.


 542,543                 21E,21F                 CDTMV4

      System timer four. Same as 538 ($21A).


 544,545                 220,221                 CDTMV5

      System timer five. Same as 538 ($21A). Timers three, four, and
      five all set flags at 554, 556 and 558 ($22A, $22C, $22E),
      respectively, when they decrement to zero.


 546,547                 222,223                 VVBLKI

      VBLANK immediate register. Normally jumps to the stage one
      VBLANK vector NMI interrupt processor at location 59345
      ($E7D1); in the new OS "B" ROMs; 59310, $E7AE). The NMI
      status register tests to see if the interrupt was due to a VBI (after
      testing for a DLI) and, if so, vectors through here to the VBI
      routine, which may be user-written. On powerup, VBI's are
      enabled and DLI's are disabled. See location 512; $200.


 548,549                 224,225                 VVBLKD

      VBLANK deferred register; system return from interrupt,
      initialized to 59710 ($E93E, in the new OS "B" ROMs; 59653;
      $E905), the exit for the VBLANK routine. NMI.

      These two VBLANK vectors point to interrupt routines that occur
      at the beginning of the VBLANK time interval. The stage one
      VBLANK routine is executed; then location 66 ($42) is tested for
      the time-critical nature of the interrupt and, if a critical code
      section has been interrupted, the stage two VBLANK routine is
      not executed with a JMP made through the immediate vector
      VVBLKI. If not critical, the deferred interrupt VVBLKD is used.
      Normally the VBLANK interrupt bits are enabled (BIT 6 at
      location 54286; $D40E is set to one). To disable them, clear BIT 6
      (set to zero).

      The normal seguence for VBLANK interrupt events is: after the
      OS test, JMP to the user immediate VBLANK interrupt routine
      through the vector at 546, 547 (above), then through SYSVBV at
      58463 ($E45F). This is directed by the OS through the VBLANK
      interrupt service routine at 59345 ($E7D1) and then on to the
      user-deferred VBLANK interrupt routine vectored at 548, 549. it
      then exits the VBLANK interrupt routine through 58466 ($E462)
      and an RTI instruction.

      If you are changing the VBLANK vectors during the interrupt
      routine, use the SETVBV routine at 58460 ($E45C). An
      immediate VBI has about 3800 machine cycles of time to use a
      deferred VBI has about 20,000 cycles. Since many of these cycles
      are executed while the electron beam is being drawn, it is
      suggested that you do not execute graphics routines in deferred
      VBI's. See the table of VBLANK processes at the end of the map
      area.

      if you create your own VBI's, terminate an immediate VBI with a
      JMP to 58463 ($E45F) and a deferred VBI with a JMP to 58466
      ($E462). To bypass the OS VBI routine at 59345 ($E7D1) entirely,
      terminate your immediate VBI with a JMP to 58466 ($E462).

      Here's an example of using a VBI to create a flashing cursor. It
      will also blink any text you display in inverse mode.

      10   FOR BLINK = 1664 TO 1680: READ B
         YTE: POKE BLINK, BYTE: NEXT BLINK
      20   POKE 548,128: POKE 549,6
      30   DATA 8,72,165,20,41,16,74,74,74,
         141
      40   DATA 243,2,104,40,76,62,233
     
      DOWNLOAD VVBLKD.BAS

      To restore the normal cursor and display, POKE 548,62 and
      POKE 549,233.


 550,551                 226,227                 CDTMA1

      System timer one jump address, initialized to 60400 ($EBF0).
      When locations 536, 537 ($218, $219) reach (count down to) zero,
      the OS vectors through here (jumps to the location specified by
      these two addresses). You can set your machine code routine
      address here for execution when timer one reaches (counts down
      to) zero. Your code should end with the RTS instruction.
      Problems may occur when timer values are set greater than 255,
      since the 6502 cannot manipulate 16-bit values directly (a
      number in the range of zero to 255 is an eight-bit value; if a value
      requires two bytes to store, such as a memory location, it is a
      16-bit value). Technically, a VBLANK interrupt could occur
      when one timer byte is being initialized and the other not yet set.
      To avoid this, keep timer values less than 255. See the Atari OS
      User's Manual, page 106, for details.

      Since the OS uses timer one, it is recommended that you use
      timer two instead, to avoid conflicts with the operation of the
      Atari. Initialized to 60396 ($EBEA) in the old ROMs, 60400
      ($EBF0) in the new ROMs. NMI


 552,553                 228,229                 CDTMA2

      System timer two jump address. Not used by the OS, available to
      user to enter the address of his or her own routine to JMP to when
      the timer two (538, 539; $21A, $21B) count reaches zero.
      Initialized to zero; the address must be user specified. NMI


 554             22A             CDTMF3

      System timer three flag, set when location 540, 541 ($21C, $21D)
      reaches zero. This register is also used by DOS as a timeout flag.


 555             22B             SRTIMR

      Software repeat timer, controlled by the IRQ device routine. It
      establishes the initial 1/2 second delay before a key will repeat.
      Stage two VBLANK establishes the 1/10 second repeat rate,
      decrements the timer and implements the auto repeat logic.
      Every time a key is pressed, STIMER is set to 48 ($30). Whenever
      SRTIMR is equal to zero and a key is being continuously pressed,
      the value of that key is continually stored in CH, location 764
      ($2FC).


 556             22C             CDTMF4

      System timer four flag. Set when location 542, 543 ($21E, $21F)
      counts down to zero.


 557             22D             INTEMP

      Temporary register used by the SETVBL routine at 58460
      ($E45C).


 558             22E             CDTMF5

      System timer five flag. Set when location 558, 559 ($22E, $22F)
      counts down to zero.

 ---------------------------------------------------------------------------

 559             22F             SDMCTL

      Direct Memory Access (DMA) enable. POKEing with zero allows
      you to turn off ANTIC and speed up processing by 30%. Of
      course, it also means the screen goes blank when ANTIC is
      turned off! This is useful to speed things up when you are doing a
      calculation that would take a long time. It is also handy to turn off
      the screen when loading a drawing, then turning it on when the
      screen is loaded so that it appears instantly, complete on the
      screen. To use it you must first PEEK(559) and save the result in
      order to return your screen to you. Then POKE 559,0 to turn off
      ANTIC. When you are ready to bring the screen back to life,
      POKE 559 with the number saved earlier.

      This location is the shadow register for 54272 ($D400), and the
      number you PEEKed above defines the playfield size, whether or
      not the missiles and players are enabled, and the player size
      resolution. To enable your options by using POKE 559, simply
      add up the values below to obtain the correct number to POKE
      into SDMCTL. Note that you must choose only one of the four
      playfield options appearing at the beginning of the list:

      Option                          Decimal   Bit
      No playfield                          0   0
      Narrow playfield                      1   0
      Standard playfield                    2   0,1
      Wide playfield                        3   0,1
      Enable missle DMA                     4   2
      Enable player DMA                     8   3
      Enable player and missile
        DMA                                12   2,3
      One line player resolution           16   4
      Enable instructions to fetch
        DMA                                32   5 (see below)

      Note that two-line player resolution is the default and that it is not
      necessary to add a value to 559 to obtain it. I have included the
      appropriate bits affected in the table above. The default is 34
      ($22).

      The playfield is the area of the TV screen you will use for display,
      text, and graphics. Narrow playfield is 128 color clocks (32
      characters wide in GR.0), standard playfield is 160 color clocks
      (40 characters), and wide playfield is 192 color clocks wide (48
      characters). A color clock is a physical measure of horizontal
      distance on the TV screen. There are a total of 228 color clocks on
      a line, but only some of these (usually 176 maximum) will be
      visible due to screen limitations. A pixel, on the other hand, is a
      logical unit which varies in size with the GRAPHICS mode. Due
      to the limitations of most TV sets, you will not be able to see all of
      the wide playfield unless you scroll into the offscreen portions.
      BIT 5 must be set to enable ANTIC operation; it enables DMA for
      fetching the display list instructions.


 560,561                 230,231                 SDLSTL

      Starting address of the display list. The display list is an
      instruction set to tell ANTIC where the screen data is and how to
      display it. These locations are the shadow for 54274 and 54275
      ($D402, $D403). You can also find the address of the DL by
      PEEKing one byte above the top of free memory:

      PRINT PEEK(741) + PEEK(742) * 256 + 1.

      However, 560 and 561 are more reliable pointers since custom
      DL's can be elsewhere in memory. Atari standard display lists
      simply instruct the ANTIC chip as to which types of mode lines to
      use for a screen and where the screen data may be found in
      memory. Normally, a DL is between 24 and 256 bytes long (most
      are less than 100 bytes, however), depending on your
      GRAPHICS mode (see location 88,89 for a chart of DL sizes and
      screen display use).

      By altering the DL, you can mix graphics modes on the same
      screen; enable fine scrolling; change the location of the screen
      data; and force interrupts (DLI's) in order to perform short
      machine language routines.

      DL bytes five and six are the addresses of the screen memory
      data, the same as in locations 88 and 89 ($58, $59). Bytes four,
      five, and six are the first Load Memory Scan (LMS) instruction.
      Byte four tells ANTIC what mode to use; the next two bytes are
      the location of the first byte of the screen RAM (LSB/MSB).
      Knowing this location allows you to write directly to the screen by
      using POKE commands (you POKE the internal character codes,
      not the ATASCII codes -- see the BASIC Reference Manual, p.
      55).

      For example, the program below will POKE the internal codes to
      the various screen modes. You can see not only how each screen
      mode handles the codes, but also roughly where the text window
      is in relation to the display screen (the 160 bytes below
      RAMTOP). Note that the GTIA modes have no text window. If
      you don't have the GTIA chip, your Atari will default to
      GRAPHICS 8, but with GTIA formatting.

      1   TRAP 10: GRAPHICS Z
      5   SCREEN = PEEK(560) + PEEK(561) *
        256
      6   TV = SCREEN + 4: TELE = SCREEN + 5
      8   DISPLAY = PEEK(TV) + PEEK(TELE) *
         256
      10  FOR N = 0 TO 255: POKE DISPLAY +
         N,N: NEXT N
      20  DISPLAY = DISPLAY + N
      30  IF DISPLAY > 40959 THEN Z = Z + 1
         : GOTO 1
      40  GOTO 10
      50  Z = Z + 1:IF Z > 60 THEN END
      60  GOTO 1

      Here's another short program which will allow you to examine the
      DL in any GRAPHICS mode:

      10  REM CLEAR SCREEN FIRST
      20  PRINT"ENTER GRAPHICS MODE": REM A
         DD 16 TO THE MODE TO SUPPRESS THE
         TEXT WINDOW
      30  INPUT A: GRAPHICS A
      40  DLIST = PEEK(560) + PEEIK(561) * 2
         56
      50  LOOK = PEEK(DLIST): PRINT LOOK;"
         ";
      60  IF LOOK <> 65 THEN DLIST = DLIST
         + 1: GOTO 50
      70  LPRINT PEEK(DLIST + 1);" ";PEEK(D
         LIST + 2)
      80  END

      The value 65 in the DL is the last instruction encountered. It tells
      ANTIC to jump to the address in the next two bytes to re-execute
      the DL, and wait for the next VBLANK. If you don't have a
      printer, change the LPRINT commands to PRINT and modify the
      routine to save the data in an array and PRINT it to the screen
      after (in GR.0).

      If you would like to examine the locations of the start of the
      Display List, screen, and text window, try:

      5   REM CLEAR SCREEN FIRST
      6   INPUT A: GRAPHICS A
      10  DIM DLIST$(10), SAVMSC$(10), TXT$
         (10)
      15  DLIST$ = "DLIST": SAVMSC$ = "SAVM
         SC": TXT$ = "TEXT"
      20  DLIST = PEEK(560) + PEEK(561) * 2
         56
      30  SAV = PEEK(88) + PEEK(89) * 256:
         TXT = PEEK(660) + PEEK(66l) * 256
      40  PRINT DLIST$;" "; DLIST,SAVMSC$;"
         ";SAV
      50  PRINT TXT$;" "; TEXT
      60  INPUT A: GRAPHICS A: GOTO 20

      Since an LMS is simply a map mode (graphics) or character
      mode (text) instruction with BIT six set, you can make any or all of
      these instructions into LMS instructions quite easily, pointing
      each line to a different RAM area if necessary. This is discussed
      in De Re Atari on implementing horizontal scrolling.

      DL's can be used to help generate some of the ANTIC screen
      modes that aren't supported by BASIC, such as 7.5 (ANTIC
      mode E) or ANTIC mode three, the lowercase with descenders
      mode (very interesting; ten scan lines in height which allow true
      descenders on lowercase letters).

      If you create your own custom DL, you POKE its address here.
      Hitting BESET or changing GRAPHICS modes will restore the
      OS DL address, however. The display list instruction is loaded
      into a special register called the Display Instruction Register (IR).
      which processes the three DL instructions (blank, jump, or
      display). It cannot be accessed directly by the programmer in
      either BASIC or machine language. A DL cannot cross a 1K
      boundary unless a jump instruction is used.

      There are only four display list instructions: blank line (uses BAK
      color), map mode, text mode, and jump. Text (character mode)
      instructions and map mode (graphics) instructions range from
      two to 15 ($2 to $F) and are the same as the ANTIC GRAPHICS
      modes. A DL instruction byte uses the following conventions
      (functions are enabled when the bit is set to one):

      Bit   Decimal   Function
      7       128     Display List Interrupt when set (enabled
                      equals one)
      6        64     Load Memory Scan. Next two bytes are the
                      LSB/MSB of the data to load.
      5        32     Enable vertical fine scrolling.
      4        16     Enable horizontal fine scrolling.
      3-0     8-1     Mode
                      0  0  1  0  Character
                        to        Modes
                      0  1  1  1
                      . . . . . . .
                      1  0  0  0  Map
                        to        Modes
                      1  1  1  1

      The above bits may be combined (i.e., DLI, scrolling and LMS
      together) if the user wishes.

      Special DL instructions (with decimal values):
      Blank 1 line  =  0   5 lines =  64
            2 lines = 16   6 lines =  80
            3 lines = 32   7 lines =  96
            4 lines = 48   8 lines = 112

      Jump instruction (JMP) = zero (three-byte instruction).
      Jump and wait for Vertical Blank (JVP) = 65 (three-byte
      instruction).
      Special instructions may be combined only with DL interrupt
      instructions.

      A Display List Interrupt is a special form of interrupt that takes
      place during the screen display when the ANTIC encounters a
      DL instruction with the interrupt BIT 7 set. See location 512
      ($200) for DLI information.

      Since DL's are too large a topic to cover properly in this manual,
      I suggest you look in the many magazines (i.e., Creative
      Computing, July 1981, August 1981; Micro, December 1981;
      Softside, #30 to 32, and BYTE, December 1981) for a more
      detailed explanation


 562             232             SSKCTL

      Serial port control register, shadow for 53775 ($D20F). Setting
      the bits in this register to one has the following effect:

      Bit    Decimal    Function
      0          1      Enable the keyboard debounce circuit.
      1          2      Enable the keyboard scanning circuit.
      2          4      The pot counter completes a read within two
                        scan lines instead of one frame time.
      3          8      Serial output transmitted as two-tone instead
                        of logic true/false (POKEY two-tone mode).
      4-6    16-64      Serial port mode control.
      7        128      Force break; serial output to zero.

      Initialized to 19 ($13) which sets bits zero, one and four.


 563             233             SPARE

      No OS use. See the note at location 651 regarding spare bytes.


 564             234             LPENH

      Light pen horizontal value shadow for 54284 ($D40C). Values
      range from zero to 227.


 565             235             LPENV

      Light pen vertical value: shadow for 54285 ($D40D). Value is the
      same as VCOUNT register for two-line resolution (see 54283;
      $D40B). Both light pen values are modified when the trigger is
      pressed (pulled low). The light pen positions are not the same as
      the normal screen row and column positions. There are 96
      vertical positions, numbered from 16 at the top to 111 at the
      bottom, each one equivalent to a scan line. Horizontal positions
      are marked in color clocks. There are 228 horizontal positions,
      numbered from 67 at the left. When the LPENH value reaches
      255, it is reset to zero and begins counting again by one to the
      rightmost edge, which has a value of seven.

      Obviously, because of the number of positions readable and the
      small size of each, a certain leeway must be given by the
      programmer when using light pen readouts on a program. At the
      time of this writing, Atari had not yet released its light pen onto
      the market, although other companies have.


 566,567                 236,237                 BRKKY

      BREAK key interrupt vector. This vector is available only with
      the version "B" OS ROMs, not the earlier version. You can use
      this vector to write your own BREAK key interrupt routine.
      Initialized to 59220 ($E754).


 568,569                 238,239                 ....

      Two spare bytes.


 570             23A             CDEVIC

      Four-byte command frame buffer (CFB) address for a device --
      used by SIO while performing serial I/O, not for user access.
      CDEVIC is used for the SIO bus ID number The other three CFB
      bytes are:


 571             23B             CCOMND

      The SIO bus command code.


 572             23C             CAUX1

      Command auxiliary byte one, loaded from location 778 ($30A)
      by SIO.


 573             23D             CAUX2

      Command auxiliary byte two, loaded from location 779 ($30B) by
      SIO.


 574             23E             TEMP

      Temporary RAM register for SIO.


 575             23F             ERRFLG

      SIO error flag; any device error except the timeout error (time
      equals zero).


 576             240             DFLAGS

      Disk flags read from the first byte of the boot file (sector one) of
      the disk.


 577             241             DBSECT

      The number of disk boot sectors read from the first disk record.


 578,579                 242,243                 BOOTAD

      The address for where the disk boot loader will be put. The
      record just read will be moved to the address specified here,
      followed by the remaining records to be read. Normally, with
      DOS, this address is 1792 ($700), the value also stored
      temporarily in RAMLO at 4, 5. Address 62189 ($F2ED) is the OS
      disk boot routine entry point (DOBOOT).


 580             244             COLDST

      Coldstart flag. Zero is normal, if zero, then pressing RESET will
      not result in reboot. If POKEd with one (powerup in progress
      flag), the computer will reboot whenever the RESET key is
      pressed. Any non-zero number indicates the initial powerup
      routine is in progress.

 If you create an AUTORUN.SYS file, it should end with an RTS
 instruction. If not, it should POKE 580 with zero and POKE 9 with one.
 You can turn any binary file that boots when loaded with DOS menu
 selection "L" into an auto-boot file simply by renaming it
 "AUTORUN.SYS". Be careful not to use the same name for any two
 files on the same disk.

 When this is combined with the disabling of the BREAK key discussed
 in location 16 ($10) and the program protection scheme discussed in
 location 138 ($8A), you have the means to protect your BASIC
 software fairly effectively from being LISTed or examined, although
 not from being copied.


 581             245             ....

      Spare byte.


 582             246             DSKTIM

      Disk time-out register (the address of the OS worst case disk time-
      out). It is said by many sources to be set to 160 at initialization
      which represents a 171 second time-out, but my system shows a
      value of 224 on initialization. Timer values are 64 seconds for
      each 60 units of measurement expressed.
      It is updated after each disk status request to contain the value of
      the third byte of the status frame (location 748; $2EC). All disk
      operations have a seven second time-out (except FORMAT),
      established by the disk handler (you had noticed that irritating
      little delay, hadn't you?). The "sleeping disk syndrome" (the
      printer suffers from this malady as well) happens when your drive
      times out, or the timer value reaches zero. This has been cured
      by the new OS "B" version ROMs.


 583-622                 247-26E                 LINBUF

      Forty-byte character line buffer, used to temporarily buffer one
      physical line of text when the screen editor is moving screen
      data. The pointer to this buffer is stored in 100, 101 ($64, $65)
      during the routine.


 623             26F             GPRIOR

      Priority selection register, shadow for 53275 ($D01B). Priority
      options select which screen objects will be "in front" of others. It
      also enables you to use all four missiles as a fifth player and
      allows certain overlapping players to have different colors in the
      areas of overlap. You add your options up as in location 559,
      prior to POKEing the total into 623. In this case, choose only one
      of the four priorities stated at the beginning. BAK is the
      background or border. You can also use this location to select
      one of GTIA GRAPHICS modes nine, ten, or eleven.

      Priority options in order                      Decimal   Bit
      Player 0 - 3, playfield 0 - 3, BAK
          (background)                                   1      0
      Player 0 - 1, playfield 0 - 3, player 2 - 3,
        BAK                                              2      1
      Playfield 0 - 3, player 0 - 3, BAK                 4      2
      Playfield 0 - 1, player 0 - 3, playfield 2 -3,
        BAK                                              8      3
      Other options
      Four missiles = fifth player                      16      4
      Overlaps of players have 3rd color                32      5
      GRAPHICS 9  (GTIA mode)                           64      6
      GRAPHICS 10 (GTIA mode)                          128      7
      GRAPHICS 11 (GTIA mode)                          192     6, 7

      It is quite easy to set conflicting priorities for players and
      playfields. In such a case, areas where both overlap when a
      conflict occurs will turn black. The same happens if the overlap
      option is not chosen.
      With the color/overlap enable, you can get a multicolor player
      by combining players. The Atari performs a logical OR to colors
      of players 0/1 and 2/3 when they overlap. Only the 0/1, 2/3
      combinations are allowed; you will not get a third color when
      players 1 and 3 overlap, for example (you will get black instead).
      If player one is pink and player 0 is blue, the overlap is green. If
      you don't enable the overlap option, the area of overlap for all
      players will be black.
      In GTIA mode nine, you have 16 different luminances of the
      same hue. In BASIC, you would use SETCOLOR 4,HUE,0. To
      see an example of GTIA mode nine, try:

      10   GRAPHICS 9: SETCOLOR 4,9,0
      20   FOR LOOP = 1 TO 15: COLOR LOOP
      30   FOR LINE = 1 TO 2
      40   FOR TEST = 1 TO 25: PLOT 4 + TES
         T, LOOP + LINE +  SPACE: NEXT TEST
      45   NEXT LINE
      50   SPACE = SPACE + 4
      60   NEXT LOOP
      70   GOTO 70: REM WITHOUT THIS LINE,
         SCREEN WILL RETURN TO GR.0
        
      DOWNLOAD GTIA9.BAS

      In GTIA mode ten, you have all nine color registers available;
      hue and luminance may be set separately for each (it would
      otherwise allow 16 colors, but there are only nine registers). Try
      this to see:

      10   N = 0: GRAPHICS 10
      20   FOR Q = 1 TO 2
      30   FOR B = 0 TO 8: POKE 704 + B, N
         * 16 + A
      35   IF A > 15 THEN A = 0
      40   COLOR B
      45   A = A + 1: N = N + 1
      50   IF N > 15 THEN N = 0
      60   NEXT B
      65   TRAP 70: NEXT Q
      70   POP: N = N + 1: FOR Z = 1 TO 200
         : NEXT Z
      75   GOTO 30
     
      DOWNLOAD GTIA10.BAS

      GTIA mode eleven is similar to mode nine except that it allows 16
      different hues, all of the same luminance. In BASIC, use
      SETCOLOR 4,O,luminance. Try this for a GTIA mode eleven
      demonstration:

      10   GRAPHICS 11
      20   FOR LOOP = 0 TO 79: COLOR LOOP:
         PLOT LOOP,0: DRAWTO LOOP,191: NEXT
          LOOP
      30   GOTO 30
     
      DOWNLOAD GTIA11.BAS

      You can use these examples with the routine to rotate colors,
      described in the text preceding location 704. GTIA mode pixels
      are long and skinny; they have a four to one horizontal length to
      height ratio. This obviously isn't very good for drawing curves
      and circles!

      GTIA modes are cleared on the OPEN command. How can you
      tell if you have the GTIA chip? Try POKE 623,64. If you have the
      GTIA, the screen will go all black. If not, you don't have it. Here
      is a short routine, written by Craig Chamberlain and Sheldon
      Leemon for COMPUTE!, which allows an Atari to test itself for the
      presence of a CTIA or GTIA chip. The routine flashes the answer
      on the screen, hut can easily be modified so a program will
      "know" which chip is present so it can adapt itself accordingly:

      10 POKE 66,1:GRAPHICS 8:POKE 709,0:PO
         KE 710,0:POKE 66,0:POKE 623,64:P0K
         E 53248,42:POKE 5326l,3:PUT#6,1
      20 POKE 53278,0:FOR K=1 TO 300:NEXT K
         :GRAPHICS 18:POKE 53248,0:POSITION
          8,5:? #6;CHR$(71-PEEK(53252));"TI
         A"
      30 POKE 708,PEEK(20):GOTO 30
     
      DOWNLOAD CTIAGTIA.BAS

      How can you get the GTIA if you don't have one? Ask your local
      Atari service representative or dealer, or write directly to Atari in
      Sunnyvale, California.

      See the GTIA/CTIA introduction at location 53248 ($D000) for
      more discussion of the chip. See BYTE, May 1982, COMPUTE!,
      July through September 1982, and De Re Atari for more on the
      GTIA chip, and the GTIA Demonstration Diskette from the Atari
      Program Exchange (APX).

 ---------------------------------------------------------------------------
 Locations 624 to 647 ($270 to $287) are used for game controllers:
 paddle, joystick and lightpen values.


 624             270             PADDL0

      The value of paddle 0 (paddles are also called pots, short for
      potentiometer); PEEK 624 returns a number between zero and
      228 ($E4), increasing as the knob is turned counter-clockwise.
      When used to move a player or cursor (i.e., PLOT
      PADDLE(0),0), test your screen first. Many sets will not display
      locations less than 48 ($30) or greater than 208 ($D0), and in
      many GRAPHICS modes you will get an ERROR 141 -- cursor
      out of range. Paddles are paired in the controller jacks, so paddle
      0 and paddle 1 both use jack one. PADDL registers are shadows
      for POKEY locations 53760 to 53767 ($D200 to $D207).


 625             271             PADDL1

      This and the next six bytes are the same as 624, but for the other
      paddles.


 626             272             PADDL2

 627             273             PADDL3

 628             274             PADDL4

 629             275             PADDL5

 630             276             PADDL6

 631             277             PADDL7

 632             278             STICK0

      The value of joystick 0. STICK registers are shadow locations for
      PIA locations 54016 and 54017 ($D300, $D301). There are nine
      possible decimal values (representing 45 degree incrememts)
      read by each joystick register (using the STICKn command),
      depending on the position of the stick:

      Decimal                   Binary
                14                       1110
                 |                         |
             10  | 6                 1010  | 0110
               \ |/                      \ |/
           11-- 15 ---7           1011-- 1111 --0111
               / |\                      / |\
              9  | 5                 1001  | 0101
                 |                         |
                13                       1101

      15 (1111) equals stick in the upright (neutral) position.
      See Micro, December 1981,for an article on making a
      proportional joystick. For an example of a machine language
      joystick driver you can add to your BASIC program, see
      COMPUTE!, July 1981.
      One machine language joystick reader is listed below, based on
      an article in COMPUTE!, August 1981:

      1   GOSUB 1000
      10  LOOK = STICK(0)
      20  X = USR(1764,LOOK): Y = USR(1781,
          LOOK)
      30  ON X GOTO 120, 100, 110
      .
      .
      .
      100 REM YOUR MOVE LEFT ROUTINE HERE
      105 GOTO 10
      110 REM YOUR MOVE RIGHT ROUTINE HERE
      115 GOTO 10
      120 ON Y GOTO 150, 130, 140
      130 REM YOUR MOVE DOWN ROUTINE HERE
      135 GOTO 10
      140 REM YOUR MOVE UP ROUTINE HERE
      145 GOTO 10
      150 REM IF X <> 1 THEN NOTHING DOING.
           BRANCH TO YOUR OTHER ROUTINES OR
           TO 155
      155 GOTO 10
      .
      .
      .
      1000 FOR LOOP = 1764 TO 1790: READ BY
           TE: POKE LOOP, BYTE: NEXT LOOP
      1010 DATA 104,104,133,213,104,41,12,7
           4,74,73,2,24,105,1
      1020 DATA 133,212,96,104,104,133,213,
           104,41,3,76,237,6
      1030 RETURN
     
      DOWNLOAD STICK0.BAS

      See locations 88, 89 ($58, $59) for an example of a USR call using
      a string instead of a fixed memory location.


 633             279             STICK1

      This and the next two locations are the same as 632, but for the
      other joysticks. These four locations are also used to determine if
      a lightpen (PEN 0 - 3) switch is pressed.


 634             27A             STICK2

 635             27B             STICK3

 636             27C             PTRIG0

      Paddle trigger 0. Used to determine if the trigger or hutton on
      paddle 0 is pressed (zero is returned) or not (one is returned).
      Since these are the same lines as the joystick left/right switches,
      you can use PTRIG for horizontal movement. PTRIG(1) -
      PTRIG(0) returns -1 (left), 0 (center), + 1 (right). The next seven
      locations are for the other paddle buttons. PTRIG 0 - 3 are
      shadows for PIA register 54016 ($D300).


 637             27D             PTRIG1

 638             27E             PTRIG2

 639             27F             PTRIG3

 640             280             PTRIG4

      PTRIG 4-7 are shadows for PIA register 54017 ($D301).


 641             281             PTRIG5

 642             282             PTRIG6

 643             283             PTRIG7

 644             284             STRIG0

      Stick trigger 0. This and the next three locations perform the
      same function as the PTRIG locations except for the joysticks.
      Like PTBIG, zero is returned when the button is pressed; one is
      returned when it is not. STRIG registers are shadow registers for
      GTIA/CTIA locations 53264 to 53267 ($D010 to $D013).


 645             285             STRIG1

 646             286             STRIG2

 647             287             STRIG3

 ---------------------------------------------------------------------------
 Locations 648 to 655 ($288 to $28F) are for miscellaneous OS use.


 648             288             CSTAT

      Cassette status register.


 649             289             WMODE

      Register to store either the read or the write mode for the cassette
      handler, depending on the operation: zero equals read, 128 ($80)
      equals write.


 650             28A             BLIM

      Cassette data record buffer size; contains the number of active
      data bytes in the cassette buffer for the record being read or
      written, at location 1021 ($3FD). Values range from zero to 128
      (cassette record size is 128; $80). The pointer to the byte being
      read or written is at 61 ($3D). The value of BLIM is drawn from
      the control bytes that precede every cassette record, as
      explained in location 1021.


 651-655                 28B-28F                 ....

      Spare bytes. It is not recommended that you use the spare bytes
      for your own program use. In later upgrades of the OS, these
      bytes may be used, causing a conflict with your program. For
      example, the new OS ROMs use locations 652 and 653 ($28C,
      $28D) in the new IRQ interrupt handler routines. It is best to use a
      protected area of memory such as page six, locations 1536 to
      1791 ($600 to $6FF).

 ---------------------------------------------------------------------------
 Locations 656 to 703 ($290 to $2BF) are used for the screen RAM
 display handler (depending on GRAPHICS mode).
 In split-screen mode, the text window is controlled by the screen editor
 (E:), while the graphics region is controlled by the display handler
 (S:), using two separate IOCB's. Two separate cursors are also
 maintained. The display handler will set AUX1 of the IOCB to split-
 screen option. Refer to the IOCB area, locations 832 to 959 ($340 to
 $3BF). See COMPUTE!, February 1982, for a program to put GR.1
 and GR.2 into the text window area. The text window uses 160 bytes of
 RAM located just below RAMTOP (see location 106; $6A). See
 location 88 ($58) for a chart of screen RAM use.


 656             290             TXTROW

      Text window cursor row; value ranges from zero to three (the text
      window has only four lines). TXTROW specifies where the next
      read or write in the text window will occur


 657,658                 291,292                 TXTCOL

      Text window cursor column; value ranges from zero to 39. Unless
      changed by the user, location 658 will always be zero (there are
      only 40 columns in the display, so the MSB will be zero). Since
      POSITION, PLOT, LOCATE and similar commands refer to the
      graphics cursor in the display area above the text window, you
      must use POKE statements to write to this area if PRINT
      statements are insufficient.


 659             293             TINDEX

      Contains the current split-screen text window GRAPHICS mode.
      It is the split-screen equivalent to DINDEX (location 87; $57) and
      is always equal to zero when location 128 ($7B) equals zero.
      Initialized to zero (which represents GR.0). You can alter the
      display list to change the text window into any GRAPHICS mode
      desired. If you do so, remember to change TINDEX to reflect that
      alteration.


 660,661                 294,295                 TXTMSC

      Address of the upper left corner of the text window. Split-screen
      equivalent of locations 88, 89 ($58, $59).


 662-667                 296-29B                 TXTOLD

      These locations contain the split-screen equivalents of OLDROW
      (90; $5A), OLDCOL (91, 92; $5B, $5C), OLDCHR (location 93,
      $5D) and OLDADR (locations 94, 95; $5E, $5F). They hold the
      split-screen cursor data.


 668             29C             TMPX1

      Temporary register, used by the display handler for the scroll
      loop count record.


 669             29D             HOLD3

      Temporary register.


 670             29E             SUBTMP

      Temporary storage.


 671             29F             HOLD2

      Temporary register.


 672             2A0             DMASK

      Pixel location mask. DMASK contains zeroes tor all bits which do
      not correspond to the specific pixel to be operated upon, and
      ones for bits which do correspond, according to the GRAPHICS
      mode in use, as follows:

      11111111  Modes 0, 1 and 2:   one pixel per screen display
                                    byte.
      11110000  Modes 9, 10 and 11: two pixels per byte.
      00001111
      11000000  Modes 3, 5 and 7:   four pixels per byte.
      00110000
      00001100
      00000011
      10000000  Modes 4, 6 and 8:   eight pixels per byte.
      01000000

      etc. to:

      00000001

      A pixel (short for picture cell or picture element) is a logical unit
      of video size which depends on the GRAPHICS mode in use for
      its dimensions. The smallest pixel is in GR.8 where it is only .5
      color clock wide and one scan line high. In GR.0 it is also only .5
      color clock wide, but it is eight scan lines high. Here is a chart of
      the pixel sizes for each mode:

                          Text Modes          Graphics modes
      GR. mode        0    1    2    3    4    5    6    7    8
      Scan lines
      per pixel       8    8   16    8    4    4    2    2    1
      Bits
      per pixel       1    1    1    2    1    2    1    2    1
      Color clocks
      per pixel      .5    1    1    4    2    2    1    1   .5
      Characters
      per line       40   20   20   --   --   --   --   --   --
      Pixels
      per width      --   --   --   40   80   80  160  160  320

      The number of pixels per screen width is based on the normal
      playfield screen. See location 559 ($22F) for information on
      playfield size.


 673             2A1             TMPLBT

      Temporary storage for the bit mask.


 674             2A2             ESCFLG

      Escape flag. Normally zero, it is set to 128 ($80) if the ESC key is
      pressed (on detection of the ESC character; 27, $1B). It is reset to
      zero following the output of the next character. To display
      ATASCII control codes without the use of an ESC character, set
      location 766 ($2FE) to a non-zero value.


 675-689                 2A3-2B1                 TABMAP

      Map of the TAB stop positions. There are 15 byte (120 bits) here,
      each bit corresponding to a column in a logical line. A one in any
      bit means the TAB is set; to clear all TABs simply POKE every
      location with zero. There are 120 TAB locations because there
      are three physical lines to one logical line in GRAPHICS mode
      zero, each consisting of 40 columns. Setting the TAB locations for
      one logical line means they will also be set for each subsequent
      logical line until changed. Each physical line in one logical line
      can have different TAB settings, however.

      To POKE TAB locations from BASIC, you must POKE in the
      number (i.e., set the bit) that corresponds to the location of the
      bit in the byte (there are five bytes in each line). For example:
      To set tabs at locations 5, 23, 27 and 32, first visualize the line as a
      string of zeros with a one at each desired tab setting:

                0000100000000000000000100010000100000000

      Then break it into groups of eight bits (one byte units). There are
      three bytes with ones (bits set), two with all zeros:

      00001000 =  8
      00000000 =  0
      00000010 =  2
      00100001 = 33
      00000000 =  0

      Converting these to decimal, we get the values listed at the right
      of each byte. These are the numbers you'd POKE into locations
      675 (the first byte) to 679 (the fifth byte on the line). On powerup
      or when you OPEN the display screen (S: or E:), each byte is
      given a value of one (i.e., 00000001) so that there are tab default
      tab stops at 7, 15, 23, etc., incrementing by eight to 119. Also,
      the leftmost screen edge is also a valid TAB stop (2, 42, and 82).
      In BASIC, these are set by the SET-TAB and CLR-TAB keys.
      TABMAP also works for the lines in the text display window in
      split-screen formats. TABMAP is reset to the default values on
      pressing RESET or changing GRAPHICS modes.
      See location 201 ($C9) about changing the TAB settings used
      when a PRINT statement encounters a comma.


 690-693                 2B2-2B5                 LOGMAP

      Logical line start bit map. These locations map the beginning
      physical line number for each logical line on the screen (initially
      24, for GR.0). Each bit in the first three bytes shows the start of a
      logical line if the bit equals one (three bytes equals eight bits *
      three equals 24 lines on the screen). The map format is as follows:

      Bit     7     6     5     4     3     2     1     0     Byte
      ------------------------------------------------------------
      Line    0     1     2     3     4     5     6     7      690
              8     9    10    11    12    13    14    15      691
             16    17    18    19    20    21    22    23      692
             --    --    --    --    --    --    --    --      693

      The last byte is ignored. The map bits are all set to one when the
      text screen is OPENed or CLEARed, when a GRAPHICS com-
      mand is issued or RESET is pressed. The map is updated as
      logical lines are entered, edited, or deleted.


 694             2B6             INVFLG

      Inverse character flag; zero is normal and the initialization value
      (i.e., normal ATASCII video codes have BIT 7 equals zero). You
      POKE INVFLG with 128 ($80) to get inverse characters (BIT 7
      equals one). This register is normally set by toggling the Atari
      logo key; however, it can be user-altered. The display handler
      XOR's the ATASCII codes with the value in INVFLG at all times.
      See location 702 ($2BE) below.

      INVFLG works to change the input, not the output. For example,
      if you have A$ = "HELLO", POKE 694, 128 will not change A$
      when you PRINT it to the screen. However, if you POKE 694, 128
      before an INPUT A$, the string will be entered as inverse.


 695             2B7             FILFLG

      Right fill flag for the DRAW command. If the current operation is
      a DRAW, then this register reads zero. If it is non-zero, the
      operation is a FILL.


 696             2B8             TMPROW

      Temporary register for row used by ROWCRS (location 84; $54).


 697,698                 2B9,2BA                 TMPCOL

      Temporary register for column used by COLCRS (locations 85,
      86; $55, $56).


 699             2BB             SCRFLG

      Scroll flag; set if a scroll occurs. It counts the number of physical
      lines minus one that were deleted from the top of the screen. This
      moves the entire screen up one physical line for each line
      scrolled off the top. Since a logical line has three physical lines,
      SCRFLG ranges from zero to two.

      Scrolling the text window is the equivalent to scrolling an entire
      GR.0 screen. An additional 20-line equivalent of bytes (800) is
      scrolled upwards in the memory below the text window address.
      This can play havoc with any data such as P/M graphics you have
      stored above RAMTOP


 700             2BC             HOLD4

      Temporary register used in the DRAW command only; used to
      save and restore the value in ATACHR (location 763; $2FB)
      during the FILL process.


 701             2BD             HOLD5

      Same as the above register.


 702             2BE             SHFLOK

      Flag for the shift and control keys. It returns zero for lowercase
      letters, 64 ($40) for all uppercase (called caps lock: uppercase is
      required for BASIC statements and is also the default mode on
      powerup). SHFLOK will set characters to all caps during your
      program if 64 is POKEd here. Returns the value 128 ($80;
      control-lock) when the CTRL key is pressed. Forced control-lock
      will cause all keys to output their control-code functions or
      graphics figures. Other values POKEd here may cause the
      system to crash. You can use this location with 694 ($2B6) above
      to convert all keyboard entries to uppercase, normal display by:

      10   OPEN #2,4,0,"K:"
      20   GET #2,A
      30   GOSUB 1000
      40   PRINT CHR$(A);: GOTO 20
      .
      .
      .
      1000 IF A = 155 THEN 1030: REM RETURN
            KEY
      1010 IF A > = 128 THEN A = A - 128: R
           EM RESTORE TO NORMAL DISPLAY
      1020 IF PEEK (702) = 0 AND A > 96 THEN
            A = A - 32: REM LOWERCASE TO UP
           PER
      1030 POKE 702,64: POKE 694,0
      1040 RETURN
     
      DOWNLOAD SHFLOK.BAS


 703             2BF             BOTSCR

      Flag for the number of text rows available for printing. 24 ($18) is
      normal for text mode GR.0; four for the text window, zero for all
      graphics modes. In all GRAPHICS modes except zero, if there is
      no text window then 703 will also read zero. The large-text
      displays in GR.1 and GR.2 are treated as graphics displays for
      this purpose. The display handler specifically checks for split-
      screen mode by looking for the variable 24 or four here. If it finds
      24 here, it assumes there is no text window; if not, it looks for the
      variable four.

      You can add a text window to GR.0 by POKEing here with four.
      The top portion (20 lines) of the screen will not scroll with the
      bottom. To write to the top part of the screen you will have to use
      the PRINT#6 statement as with modes one and two. One possible
      application of this would be to keep a fixed menu at the top of the
      screen while scrolling the bottom part, as done with the DOS
      menu.

 ---------------------------------------------------------------------------
 Locations 704 to 712 ($2C0 to $2C8) are the color registers for players,
 missiles, and playfields. These are the RAM shadow registers for
 locations 53266 to 53274 ($D012 to $D01A). For the latter, you can use
 the SETCOLOR command from BASIC. For all registers you can
 POKE the desired color into the location by using this formula:

 COLOR = HUE * 16 + LUMINANCE

 It is possible to get more colors in GR.8 than the one (and a half) that
 Atari says is possible by using a technique called artifacting. There is a
 small example of artifacting shown at location 710 ($2C6). See De Re
 Atari, Your Atari 400/800, Creative Computing, June 1981, and
 COMPUTE!, May 1982.

 Here are the 16 colors the Atari produces, along with their POKE
 values for the color registers. The POKE values assume a luminance of
 zero. Add the luminance value to the numbers to brighten the color.
 The color registers ignore BIT 0; that's why there are no "odd" values
 for luminance, just even values.

 Color             Value         Color             Value
 Black           0,      0       Medium blue     8,    128
 Rust            1,     16       Dark blue       9,    144
 Red-orange      2,     32       Blue-grey      10,    160
 Dark orange     3,     48       Olive green    11,    176
 Red             4,     64       Medium green   12,    192
 Dk lavender     5,     80       Dark green     13,    208
 Cobalt blue     6,     96       Orange-green   14,    224
 Ultramarine     7,    112       Orange         15,    240

 The bit use of the PCOLR and COLOR registers is as follows:

 Bit     7  6  5  4  3  2  1  0
         --color--   luminance unused
 Grey    0  0  0  0  0  0  0  Darkest
 Rust    0  0  0  1  0  0  1
          etc. to:      etc. to:
 Orange  1  1  1  1  1  1  1  Lightest

 When you enable the color overlap at location 623 ($26F), ANTIC
 performs a logical OR on the overlap areas. For example:

          01000010 Red, luminance two
     OR   10011010 Darkblue,luminance ten
          --------
 Result = 10011010  Dark green, luminance ten

 Here's a short machine language routine which will rotate the colors in
 registers 705 to 712:

      10   DIM ROT$(30)
      20   FOR LOOP = 1 TO 27: READ BYTE: R
         OT$(LOOP,LOOP) = CHR$(BYTE): NEXT
         LOOP
      .
      .    PUT YOUR GRAPHICS ROUTINE HERE
      .
      100  CHANGE = USR(ADR(ROT$))
      105  FOR LOOP = 1 TO 200: NEXT LOOP:
          GOTO 100
      110  DATA 104,162,0,172,193,2,189,194
          ,2,157
      120  DATA 193,2,232,224,8,144,245,140
          ,200,2
      130  DATA  96,65,65,65,65,65,65

 If you wish to rotate the colors in registers 704 to 711 instead, change
 lines 110 and 120 to read as follows:

      110  DATA 104,162,0,172,192,2,189,193
          ,2,157
      120  DATA 192,2,232,224,8,144,245,140
          ,199,2
         
      DOWNLOAD BOTSCR.BAS

 If you wish to include all of the registers 704 to 712 in the routine, make
 the changes as above and change the eight in line 120 to nine and
 restore the 199 to 200 in line 120. This routine works well with the
 GTIA demos at location 623 ($26F).

 For further detail, refer to your Atari BASIC Reference Manual, pp. 45
 -56, and the GTIA Demo Disk from APX.


 704             2C0             PCOLR0

      Color of player 0 and missile 0. Locations 704 to 707 are also
      called COLPM# in some sources. This is the shadow for 53266
      ($D012). In GTIA mode ten, 704 holds the background color
      (BAK; normally held by 712). You cannot use the SETCOLOR
      commands to change the PCOLR registers; color values must be
      POKEd into them.


 705             2C1             PCOLR1

      Color of player and missile 1. Shadow for 53267 ($D013).


 706             2C2             PCOLR2

      Color of player and missile 2. Shadow for 53268 ($D014).


 707             2C3             PCOLR3

      Color of player and missile 3. When the four missiles are
      combined to make a fifth player, it takes on the color in location
      711 (COLOR3). Shadow for 53269 ($D015).


 708             2C4             COLOR0

      Color register zero, color of playfield zero, controlled by the
      BASIC SETCOLOR0 command. In GRAPHICS 1 and
      GRAPHICS 2, this color is used for the uppercase letters.
      Shadow for 53270 ($D016). You can change the values in all of
      the COLOR registers from BASIC by using either the
      SETCOLOR command or a POKE.


 709             2C5             COLOR1

      The next four locations are the same as location 708 for the
      different playfields and SETCOLOB commands. In GR.1 and
      GR.2, this register stores the color for lowercase letters.
      COLOR1 is also used to store the luminance value of the color
      used in GR.0 and GR.8. Shadow for 53271 ($D017).


 710             2C6             COLOR2

      The same as above for playfield two; in GR.1 and GR.2, this
      register stores the color of the inverse uppercase letters. Shadow
      for 53272 ($D018). Used for the background color in GR.0 and
      GR.8. Both use COLOR1 for the luminance value.

      Despite the official limitations of color selection in GR.8, it is
      possible to generate additional colors by "artifacting", turning
      on specific pixels (.5 color clock each) on the screen. Taking
      advantage of the physical structure of the TV set itself, we
      selectively turn on vertical lines of pixels which all show the same
      color. For example:

      10   A = 40: B = 30: C = 70: D = 5: F
          = 20   GRAPHICS 8: POKE 87,7: P0K
         E 710,0: POKE 709,15: COLOR 1
      30   PLOT A,D: DRAWTO A,C: COLOR 2: P
         LOT F,D: DRAWTO F,C:
      40   PLOT A + 1,D: DRAWTO A + 1,C
      50   COLOR 3: PLOT B,D: DRAWTO B,C
      60   GOTO 60
     
      DOWNLOAD COLOR2.BAS

      A little experimentation with this will show you that the colors
      obtained depend on which pixels are turned on and how close
      together the pixel columns are. There are four "colors" you can
      obtain, as shown before. Pixels marked one are on; marked zero
      means they are off. Each pair of pixels is one color clock. Three
      color clocks are shown together for clarity:

      00:01:00 = color A     00:11:00 = color B
      00:10:00 = color C     00:01:10 = color D

      See BYTE, May 1982, De Re Atari, and Your Atari 400/800.


 711             2C7             COLOR3

      The same as the above but for playfield three. Also, the color for
      GR.1 and GR.2 inverse lowercase letters. Shadow for 53273
      ($D019).


 712             2C8             COLOR4

      The same as the above but for the background (BAK) and border
      color. Shadow for 53274 ($D01A). In GTIA mode ten, 704 stores
      the background color (BAK), while 712 becomes a normal color
      register.

      Here are the default (powerup) values for the COLOR registers
      (PCOL registers are all set to zero on powerup):

      Register      Color  =  Hue  Luminance
      708  (CO.0)     40       2       8
      709  (CO.1)    202      12      10
      710  (CO.2)    148       9       4
      711  (CO.3)     70       4       6
      712  (CO.4)      0       0       0

 ----------------------------------------------------------------------------
 Locations 713 to 735 ($2C9 to $2DF) are spare bytes. Locations 736 to
 767 ($2E0 to $2FF) are for miscellaneous use.


 736-739                 2E0-2E3                 GLBABS

      Global variables, or, four spare bytes for non DOS users. For
      DOS users they are used as below:


 736-737                 2E0-2E1                 RUNAD

      Used by DOS for the run address read from the disk sector one or
      from a binary file. Upon completion of any binary load, control
      will normally be passed back to the DOS menu. However, DOS
      can be forced to pass control to any specific address by storing
      that address here. If RUNAD is set to 40960 ($A000), then the left
      cartridge (BASIC if inserted) will be called when the program is
      booted.

      With DOS 1.0, if you POKE the address of your binary load file
      here, the file will be automatically run upon using the DOS
      Binary Load (selection L). Using DOS 1.0's append (/A) option
      when saving a binary file to disk, you can cause the load address
      POKEd here to be saved with the data. In DOS 2.0, you may
      specify the initialization and the run address with the program
      name when you save it to disk (i.e.,
      GAME.OBJ,2000,4FFF,4F00,4000). DOS 2.0 uses the /A option
      to merge files. In order to prevent your binary files from running
      automatically upon loading in DOS 2.0, use the /N appendage to
      the file name when loading the file.

      For users of CompuServe, there is an excellent little BASIC
      program (with machine language subroutines) to create autoboot
      files, chain machine language files with BASIC and to add an 850
      autoboot file in the Popular Electronics Magazine (PEM) access
      area. It is available free for downloading.


 738-739                 2E2-2E3                 INITAD

      Initialization address read from the disk. An autoboot file must
      load an address value into either RUNAD above or INITAD. The
      code pointed to by INITAD will be run as soon as that location is
      loaded. The code pointed to by RUNAD will be executed only
      after the entire load process has been completed. To return
      control to DOS after the execution of your program, end your
      code with an RTS instruction.


 740             2E4             RAMSIZ

      RAM size, high byte only; this is the number of pages that the top
      of RAM represents (one page equals 256 bytes). Since there can
      never be less than a whole page, it becomes practical to measure
      RAM in those page units. This is the same value as in RAMTOP,
      location 106 ($6A), passed here from TRAMSZ, location 6. Space
      saved by moving RAMSIZ or RAMTOP has the advantage of
      being above the display area. Initialized to 160 for a 48K Atari.


 741,742                 2E5,2E6                 MEMTOP

      Pointer to the top of free memory used by both BASIC (which
      calls it HIMEM) and the OS, passed here from TRAMSZ, location
      6 after powerup. This address is the highest free location in RAM
      for programs and data. The value is updated on powerup, when
      RESET is pressed, when you change GRAPHICS mode, or when
      a channel (IOCB) is OPENed to the display. The display list starts
      at the next byte above MEMTOP.

      The screen handler will only OPEN the S: device if no RAM is
      needed below this value (i.e. there is enough free RAM below
      here to accommodate the requested GRAPHICS mode change).
      Memory above this address is used for the display list and the
      screen display RAM. Also, if a screen mode change would
      extend the screen mode memory below APPMHI (locations 14,
      15: $E, $F), then the screen is set back for GR.0, MEMTOP is
      updated, and an error is returned to the user. Otherwise the
      mode change will take place and MEMTOP will be updated.

      Space saved by moving MEMTOP is below the display list. Be
      careful not to overwrite it if you change GRAPHICS modes in
      mid-program. When using memory below MEMTOP for storage,
      make sure to set APPMHI above your data to avoid having the
      screen data descend into it and destroy it.


 743,744                 2E7,2E8                 MEMLO

      Pointer to the bottom of free memory, initialized to 1792 ($700)
      and updated by the presence of DOS or any other low-memory
      application program. It is used by the OS; the BASIC pointer to
      the bottom of free memory is at locations 128, 129 ($80, $81). The
      value in MEMLO is never altered by the OS after powerup.

      This is the address of the first free location in RAM available for
      program use. Set after all FMS buffers have been allocated (see
      locations 1801 and 1802; $709 and $70A). The address of the last
      sector buffer is incremented by 128 (the buffer size in bytes) and
      the value placed in MEMLO. The value updates on powerup or
      when RESET is pressed. This value is passed back to locations
      128, 129 ($80, $81) on the execution of the BASIC NEW
      command, but not RUN, LOAD or RESET.

      If you are reserving space for your own device driver(s) or
      reserving buffer space, you load your routine into the address
      specified by MEMLO, add the size of your routine to the MEMLO
      value, and POKE the new value plus one back into MEMLO.

      When you don't have DOS or any other application program
      using low-memory resident, MEMLO points to 1792 ($700. With
      DOS 2.0 present, MEMLO points to 7420 ($1CFC). If you change
      the buffer defaults mentioned earlier, you will raise or lower this
      latter value by 128 ($80) bytes for every buffer added or deleted,
      respectively. When you boot up the 850 Interface with or without
      disk, you add another 1728 ($6C0) bytes to the value in MEMLO.

      You can alter MEMLO to protect an area of memory below your
      program. This is an alternative to protecting an area above
      RAMTOP (location 106; $6A) and avoids the problem of the
      CLEAR SCREEN routine destroying data. However, unless you
      have created a MEM.SAV file, the data will be wiped out when
      you call DOS. To alter MEMLO, you start by POKEing WARMST
      (location 8) with zero, then doing a JMP to the BASIC cartridge
      entry point at 40960($A000) after defining your area to protect.
      For example, try this:

      10 DIM MEM$(24):PROTECT=700:REM NUMBE
         R OF BYTES TO CHANGE
      15 HIBYTE=INT(PROTECT/256):LOBYTE=PRO
         TECT-256*HIBYTE
      20 FOR N=1 TO 24:READ PRG:MEM$(N)=CHR
         $(PRG):NEXT N
      30 MEM$(6,6)=CHR$(LOBYTE):MEM$(14,14)
         =CHR$(HIBYTE)
      40 RESERVE=USR(ADR(MEM$))
      50 DATA 24,173,231,2,105,0,141,231,2,
         173,232,2,105
      60 DATA 0,141,232,2,169,0,133,8,76,0,
         160
        
      DOWNLOAD MEMLO.BAS

      You will find the address of your reserved memory by: PRINT
      PEEK(743) + PEEK(744) * 256 before you run the program. This
      program will wipe itself out when run. Altering MEMLO is the
      method used by both DOS and the RS-232 port driver in the 850
      Interface. See COMPUTE!, July 1981.


 745             2E9             ....

      Spare byte.


 746-749                 2EA-2ED                 DVSTAT

      Four device status registers used by the I/O status operation as
      follows:

      746 ($2EA) is the device error status and the command status
      byte. If the operation is a disk I/O, then the status returned is that
      of the 1771 controller chip in your Atari disk drive. Bits set to one
      return the following error codes:

      Bit  Decimal  Error
      0       1     An invalid command frame was received (error).
      1       2     An invalid data frame was received.
      2       4     An output operation was unsuccessful.
      3       8     The disk is write-protected.
      4      16     The system is inactive (on standby).
      7      32     The peripheral controller is "intelligent" (has its
                    own microprocessor: the disk drive). All Atari
                    devices are intelligent except the cassette
                    recorder, so BIT 7 will normally be one when a
                    device is attached.

      747 ($2EB) is the device status byte. For the disk, it holds the
      value of the status register of the drive controller. For the 850
      Interface, it holds the status for DSR,CTS,CRX and RCV when
      concurrent I/O is not active (see the 850 Interface Manual). It also
      contains the AUX2 byte value from the previous operation (see
      the IOCB description at 832 to 959; $340 to $3AF).
      748 ($2EC) is the maximum device time-out value in seconds. A
      value of 60 here represents 64 seconds. This value is passed back
      to location 582 ($246) after every disk status request. Initialized to
      31.
      749 ($2ED) is used for number of bytes in output buffer. See 850
      Manual, p. 43.
      When concurrent I/O is active, the STATUS command returns
      the number of characters in the input buffer to locations 747 and
      748, and the number of characters in the output buffer to location
      749.


 750,751                 2EE,2EF                 CBAUDL/H

      Cassette baud rate low and high bytes. Initialized to 1484
      ($5CC), which represents a nominal 600 baud (bits per second).
      After baud rate calculations, these locations will contain POKEY
      values for the corrected baud rate. The baud rate is adjusted by
      SIO to account for motor variations, tape stretch, etc. The
      beginning of every cassette record contains a pattern of
      alternating off/on bits (zero/one) which are used solely for speed
      (baud) correction.


 752             2F0             CRSINH

      Cursor inhibit flag. Zero turns the cursor on; any other number
      turns the cursor off. A visible cursor is an inverse blank (space)
      character. Note that cursor visibility does not change until the
      next time the cursor moves (if changed during a program). If you
      wish to change the cursor status without altering the screen data,
      follow your CRSINH change with a cursor movement (i.e., up,
      down) sequence. This register is set to zero (cursor restored) on
      powerup, RESET, BREAK, or an OPEN command to either the
      display handler (S:) or screen editor (E:). See location 755 for
      another means to turn off the cursor.


 753             2F1             KEYDEL

      Key delay flag or key debounce counter; used to see if any key
      has been pressed. If a zero is returned, then no key has been
      pressed. If three is returned, then any key. It is decremented
      every stage two VBLANK (1/60 or 1/30th second) until it reaches
      zero. If any key is pressed while KEYDEL is greater than zero, it
      is ignored as "bounce." See COMPUTE!, December 1981, for a
      routine to change the keyboard delay to suit your own typing
      needs.


 754             2F2             CH1

      Prior keyboard character code (most recently read and
      accepted). This is the previous value passed from 764 ($2FC). If
      the value of the new key code equals the value in CH1, then the
      code is accepted only if a suitable key debounce delay has taken
      place since the prior value was accepted.


 755             2F3             CHACT

      Character Mode Register. Zero means normal inverse
      characters, one is blank inverse characters (inverse characters
      will be printed as blanks, i.e., invisible), two is normal
      characters, three is solid inverse characters. Four to seven is the
      same as zero to three, but prints the display upside down.
      This register also controls the transparency of the cursor. It is
      transparent with values two and six, opaque with values three
      and seven. The cursor is absent with values zero, one, four and
      five.

      Toggling BIT 0 on and off can be a handy way to produce a
      blinking effect for printed inverse characters (characters with
      ATASCII values greater than 128 -- those that have BIT 7 set).
      Shadow for 54273 ($D401). There is no visible cursor for the
      graphics mode output. CHACT is initialized to two.
      Here's an example of blinking text using this register:

      10 CHACT=755:REM USE INVERSE FOR WORD
         S BELOW
      15 PRINT "[THIS IS A TEST OF BLINKING ]
        [TEXT]"
      20 POKE CHACT,INT(RND(0)*4)
      30 FOR N=1 TO 100:NEXT N:GOTO 15

      See COMPUTE!, December 1981.
      Using a machine language routine and page six space, try:

      10 PAGE=1536:EXIT=1568
      20 FOR N=PAGE TO EXIT:READ BYTE:POKE
         N,BYTE:NEXT N
      30 PGM=USR(PAGE)
      40 PRINT "[THIS] IS A [TEST] OF [BLINKING]
         TEXT":REM MAKE SOME WORDS INVERSE
      50 GOTO 50
      60 DATA 104,169,17,141,40,2,169,6,141
         ,41
      70 DATA 2,169,30,141,26,2,98,173,243,
         2
      80 DATA 41,1,73,1,141,243,2,169,30,14
         1,26,2,96
        
      DOWNLOAD CHACT.BAS

      The blink frequency is set .5 second; to change it, change the
      30 in line 80 to any number from one (1/30 second) to 255 (eight
      .5 seconds). For another way to make the cursor visible or
      invisible, see locations 752 above.


 756             2F4             CHBAS

      Character Base Register, shadow for 54281 ($D409). The default
      (initialization value) is 224 ($E0) for uppercase characters and
      numbers; POKE CHBAS with 226 ($E2) to get the lowercase and
      the graphics characters in GR.1 and GR.2. In GR.0 you get the
      entire set displayed to the screen, but in GR.1 and GR.2, you
      must POKE 756 for the appropriate half-set to be displayed.

      How do you create an altered character set? First you must
      reserve an area in memory for your set (512 or 1024 bytes; look at
      location 106; $6A to see how). Then either you move the ROM set
      (or half set, if that's all you intend to change) into that area and
      alter the selected characters, or you fill up the space with bytes
      which make up your own set. Then you POKE 756 with the MSB
      of the location of your set so the computer knows where to find it.

      What does an altered character set look like? Each character is a
      block one byte wide by eight bytes high. You set the bits for the
      points on the screen you wish to be "on" when displayed. Here
      are two examples:

      one byte wide:
      00100000 = 32             #
      00010000 = 16              #
      00010000 = 16              #
      00010000 = 16              #
      00011110 = 30              ####
      00000010 =  2                 #
      00001100 = 12               ##
      00010000 = 16              #

      Hebrew letter Lamed


      one byte wide:
      10000001 = 129          #      #
      10011001 = 153          #  ##  #
      10111101 = 189          # #### #
      11111111 = 255          ########
      11111111 = 255          ########
      10111101 = 189          # #### #
      10011001 = 153          #  ##  #
      10000001 = 129          #      #

      Tie-fighter

      You can turn these characters into DATA statements to be POKEd
      into your reserved area by using the values for the bytes as in the
      above examples. To change the ROM set once it is moved, you
      look at the internal code (see the BASIC Reference Manual, p.
      55) and find the value of the letter you want to replace--such as
      the letter A--code 33. Multiply this by eight bytes for each code
      number from the start of the set (33 * eight equals 264). You then
      replace the eight bytes used by the letter A, using a FOR-NEXT
      loop with the values for your own character. For example, add
      these lines to the machine language found a few pages further on:

      1000 FOR LOOP=1 TO 4:READ CHAR:SET=CH
           ACT+CHAR*8
      1010 FOR TIME=0 TO 7:READ BYTE:POKE S
           ET+TIME,BYTE: NEXT TIME
      1020 NEXT LOOP
      1030 DATA 33,0,120,124,22,22,124,120,
           0
      1040 DATA 34,0,126,82,82,82,108,0,0
      1050 DATA 35,56,84,254,238,254,68,56,
           0
      1060 DATA 36,100,84,76,0,48,72,72,48
      2000 END

      RUN it and type the letters A to D.
      Why 224 and 226? Translated to hex, these values are $E0 and
      $E2, respectively. These are the high bytes (MSB) for the location
      of the character set stored in ROM: $E000 (57344) is the address
      for the start of the set (which begins with punctuation, numbers
      and uppercase letters), and $E200 (57856), for the second half of
      the ROM set, lowercase and graphic control characters (both
      start on page boundaries). The ROM set uses the internal order
      given on page 55 of your BASIC Reference Manual, not the
      ATASCII order. See also location 57344 ($E000).

      You will notice that using the PRINT#6 command will show you
      that your characters have more than one color available to them
      in GR.1 and GR.2. Try PRINTing lowercase or inverse
      characters when you are using the uppercase set. This effect can
      be very useful in creating colorful text pages. Uppercase letters,
      numbers, and special characters use color register zero (location
      708; $2C4 - orange) for normal display, and color register two
      (710; $2C6 - blue) for inverse display. Lowercase letters use
      register one (709; $2C5 - aqua) for normal display and register
      three (711; $2C7 - pink) for inverse. See COMPUTE!, December
      1981, page 98, for a discussion of using the CTRL keys with letter
      keys to get different color effects.

      One problem with POKEing 756 with 226 is that there is no blank
      space character in the second set: you get a screen full of hearts.
      You have two choices: you can change the color of register zero
      to the same as the background and lose those characters which
      use register zero--the control characters--but get your blanks
      (and you still have registers one, two and three left). Or you can
      redefine your own set with a blank character in it. The latter is
      obviously more work. See "Ask The Readers," COMPUTE!, July
      1982.

      It is seldom mentioned in the manuals, but you cannot set 756 to
      225 ($El) or any other odd number. Doing so will only give you
      screen garbage. The page number 756 points to must be evenly
      divisible by two.

      When you create your own character set and store it in memory,
      you need to reserve at least 1K for a full character set (1024 bytes
      --$400 or four pages), and you must begin on a page boundary.
      In hex these are the numbers ending with $XX00 such as $C000
      or $600 because you store the pointer to your set here in 756; it
      can only hold the MSB of the address and assumes that the LSB is
      always zero--or rather a page boundary. You can reserve
      memory by:

      POKE 106,PEEK(106)-4 (or any multiple of four)

      And do a GRAPHICS command immediately after to have your
      new memory value accepted by the computer. If you are using
      only one half of the entire set, for GR.1 or GR.2, you need only
      reserve 512 bytes, and it may begin on a .5K boundary (like
      $E200; these are hexadecimal memory locations that end in
      $X200). If you plan to switch to different character sets, you will
      need to reserve the full 1K or more, according to the number of
      different character sets you need to display. RAM for half-K sets
      can be reserved by:

      POKE 106,PEEK(106)-2 (or a multiple of two)

      The location for your set will then begin at PEEK(106)*256.
      Because BASIC cannot always handle setting up a display list for
      GR.7 and GR.8 when you modify location 106 by less than 4K (16
      pages), you may find you must use PEEK(106)-16. See location
      88,89 ($58,$59) and 54279 ($D407) for information regarding
      screen use and reserving memory.

      Make sure you don't have your character set overlap with your
      player/missile graphics. Be very careful when using altered
      character sets in high memory. Changing GRAPHICS modes, a
      CLEAR command, or scrolling the text window all clear memory
      past the screen display. When you scroll the text window, you
      don't simply scroll the four lines; you actually scroll a full 24 (20
      additional lines * 40 bytes equals 800 bytes scrolled past
      memory)! This messes up the memory past the window display
      address, so position your character sets below all possible
      interference (or don't scroll or clear the screen).

      You can create and store as many character sets as your memory
      will allow. You switch back and forth between them and the ROM
      set by simply POKEing the MSB of the address into 756. Of
      course, you can display only one set at a time unless you use an
      altered display list and DLI to call up other sets. There are no
      restrictions outside of memory requirements on using altered
      character sets with P/M graphics as long as the areas reserved for
      them do not overlap.

      A GRAPHICS command such as GR.0, RESET or a DOS call
      restores the character set pointer to the ROM location, so you
      must always POKE it again with the correct location of your new
      set after any such command. A useful place to store these sets is
      one page after the end of RAM, assuming you've gone back to
      location 106 ($6A) and subtracted the correct number of pages
      from the value it holds (by POKE 106,PEEK(106) minus the
      number of pages to be reserved; see above). Then you can reset
      the character set location by simply using POKE
      756,PEEK(106)+1 (the plus one simply makes sure you start at
      the first byte of your set).

      A full character set requires 1024 bytes (1K: four pages) be
      reserved for it. Why? Because there are 128 characters, each
      represented by eight bytes, so 128 * eight equals 1024. If you are
      using a graphics mode that uses only half the character set, you
      need only reserve 512 bytes (64 * eight equals 512). Remember to
      begin either one on a page boundary (1K boundary for full sets or
      .5K for half sets). By switching back and forth between two
      character sets, you could create the illusion of animation.

      Many magazines have published good utilities to aid in the
      design of altered character sets, such as the January 1982
      Creative Computing, and SuperFont in COMPUTE!, January
      1982. I suggest that you examine The Next Step from Online,
      Instedit from APX, or FontEdit from the Code Works for very
      useful set generators. One potentially useful way to alter just a
      few of the characters is to duplicate the block of memory which
      holds the ROM set by moving it byte by byte into RAM. A BASIC
      FOR-NEXT loop can accomplish this, although it's very slow. For
      example:

      5 CH=57344
      10 START=PEEK(106)-4:PLACE=START*256:
         POKE 106,PEEK(106)-5:GRAPHICS 0: RE
         M RESERVE EXTRA IN CASE OF SCREEN
         CLEAR
      20 FOR LOOP=0 TO 1023:POKE PLACE+LOOP
         ,PEEK(CH+LOOP):NEXT LOOP:REM MOVE
         THE ROM SET
      30 POKE 756,PLACE/256:REM TELL ANTIC
         WHERE CHSET IS

      Here's a machine language routine to move the set:

      10 DIM BYTE$(80)
      15 REM MEM-1 TO PROTECT SET FROM CLEA
         R SCREEN DESTRUCTION (SEE LOC.88)
      20 MEM=PEEK(106)-4:POKE 106,MEM-1: CHA
         CT=MEM*256:GRAPHICS 0
      30 FOR LOOP=1 TO 32:READ PGM:BYTE$(LO
         OP,LOOP)=CHR$(PGM):NEXT LOOP
      40 DATA 104,104,133,213,104,133,212
      50 DATA 104,133,215,104,133,214,162
      60 DATA 4,160,0,177,212,145,214
      70 DATA 200,208,249,230,213,230,215
      80 DATA 202,208,240,96
      90 Z=USR(ADR(BYTE$),224*256,CHACT)
      .
      . ADD YOUR OWN ALTERATION PROGRAM OR
      THE EARLIER EXAMPLE HERE
      .
      .
      1500 POKE MEM-1,0:POKE 756,MEM

      If you have Microsoft BASIC or BASIC A+, you can do this very
      easily with the MOVE command!

      Remember, when altering the ROM set, that the characters aren't
      in ATASCII order; rather they are in their own internal order.
      Your own set will have to follow this order if you wish to have the
      characters correlate to the keyboard and the ATASCII values.
      See page 55 of your BASIC Reference Manual for a listing of the
      internal order. Creative Computing, January 1982, had a good
      article on character sets, as well as a useful method of
      transferring the ROM set to RAM using string manipulation. See
      also "Using Text Plot for Animated Games" in COMPUTE!, April
      1982, for an example of using character sets for animated
      graphics.


 757-761                 2F5-2F9                 ....

      Spare bytes.


 762             2FA             CHAR

      Internal code value for the most recent character read or written
      (internal code for the value in ATACHR below). This register is
      difficult to use with PEEK statements since it returns the most
      recent character; most often the cursor value (128, $80 for a
      visible, zero for an invisible cursor).


 763             2FB             ATACHR

      Returns the last ATASCII character read or written or the value of
      a graphics point. ATACHR is used in converting the ATASCII
      code to the internal character code passed to or from CIO. It also
      returns the value of the graphics point. The FILL and DRAW
      commands use this location for the color of the line drawn,
      ATACHR being temporarily loaded with the value in FILDAT,
      location 765; $2FD. To force a color change in the line, POKE the
      desired color number here (color * sixteen + luminance). To see
      this register in use as character storage, try:

      10 OPEN#2,4,0,"K:"
      20 GET#2,A
      30 PRINT PEEK(763);" "; CHR$(A)
      40 GOTO 20

      Make sure the PEEK statement comes before the PRINT CHR$
      statement, or you will not get the proper value returned. When
      the RETURN key is the last key pressed, ATACHR will show a
      value of 155.


 764             2FC             CH

      Internal hardware value for the last key pressed. POKE CH with
      255 ($FF; no key pressed) to clear it. The keyboard handler gets
      all of its key data from CH. It stores the value 255 here to indicate
      the key code has been accepted, then passes the code to CH1,
      location 754 ($2F2). If the value in CH is the same as in CH1, a
      key code will be accepted only if the proper key debounce delay
      time has transpired. If the code is the CTRL-1 combination (the
      CTRL and the "1" keys pressed simultaneously), then the
      start/stop flag at 767 ($2FF) is complemented, but the value is not
      stored in CH. The auto repeat logic will also store store key
      information here as a result of the continuous pressing of a key.
      This is neither the ATASCII nor the internal code value; it is the
      "raw" keyboard matrix code for the key pressed. The table for
      translation of this code to ATASCII is on page 50 of the OS User's
      Manual. In a two-key operation, BIT 7 is set if the CTRL key is
      pressed, BIT 6 if the SHIFT key is pressed. The rest of the bytes
      are the code (ignored if both BITs 7 and 6 are set). Only the code
      for the last key pressed is stored here (it is a global variable for
      keyboard).

      When a read request is issued to the keyboard, CH is set to 255
      by the handler routine. After a keycode has been read from this
      register, it is reset to 255. BREAK doesn't show here, and CTRL
      and SHIFT will not show here on their own. However, the inverse
      toggle (Atari logo key), CAPS/LOWR, TAB and the ESC keys
      will show by themselves. You can examine this register with:

      10 LOOK=PEEK(764)
      20 PRINT "KEY PRESSED = ";LOOK
      30 POKE 764,255
      40 FOR LOOP=1 TO 250:NEXT LOOP
      50 GOTO 10

      See COMPUTE!'s First Book of Atari for an example of using this
      register as a replacement for joystick input.


 765             2FD             FILDAT

      Color data for the fill region in the XIO FILL command.


 766             2FE             DSPFLG

      Display flag, used in displaying the control codes not associated
      with an ESC character (see location 674; $2A2). If zero is
      returned or POKEd here, then the ATASCII codes 27 - 31, 123 -
      127, 187 - 191 and 251 - 255 perform their normal display screen
      control functions (i.e., clear screen, cursor movement,
      delete/insert line, etc.). If any other number is returned, then a
      control character is displayed (as in pressing the ESC key with
      CTRL-CLEAR for a graphic representation of a screen clear).
      POKEing any positive number here will force the display instead
      of the control code action. There is, however, a small bug, not
      associated with location 766, in Atari BASIC: a PRINTed CTRL-R
      or CTRL-U are both treated as a semicolon.


 767             2FF             SSFLAG

      Start/stop display screen flag, used to stop the scrolling of the
      screen during a DRAW or graphics routine, a LISTing or a
      PRINTing. When the value is zero, the screen output is not
      stopped. When the value is 255 ($FF; the one's complement), the
      output to the screen is stopped, and the machine waits for the
      value to become zero again before continuing with the scrolling
      display. Normally SSFLAG is toggled by the user during these
      operations by pressing the CTRL-1 keys combination to both start
      and stop the scroll. Set to zero by RESET and powerup.

 ---------------------------------------------------------------------------

 PAGE THREE

 Locations 768 to 831 ($300 to $33F) are used for the device handler and
 vectors to the handler routines (devices S:, P:, E:, D:, C:, R: and K:).
 A device handler is a routine used by the OS to control the transfer of
 data in that particular device for the task allotted (such as read, write,
 save, etc.). The resident D: handler does not conform entirely with the
 other handler--SIO calling routines. Instead, you use the DCB to
 communicate directly with the disk handler. The device handler for R:
 is loaded in from the 850 interface module. See De Re Atari, the 850
 Interface Manual, and the OS Listings pages 64 - 65.

 Locations 768 to 779 ($300 to $30B) are the resident Device Control
 Block (DCB) addresses, used for I/O operations that require the serial
 bus; also used as the disk DCB. DUP.SYS uses this block to interface
 the FMS with the disk handler. The Atari disk drive uses a serial access
 at 19,200 baud (about 20 times slower than the Apple!). It has its own
 microprocessor, a 6507, plus 128 bytes of RAM, a 2316 2K masked
 ROM chip (like a 2716), a 2332 RAM-I/O timer chip with another 128
 bytes of RAM (like the PIA chip) and a WD 1771 FD controller chip.
 See the "Outpost Atari" column, Creative Computing, May 1982, for
 an example of using the disk DCB.

 All of the parameters passed to SIO are contained in the DCB. SIO
 uses the DCB information and returns the status in the DCB for
 subsequent use by the device handler.


 768             300             DDEVIC

      Device serial bus ID (serial device type) set up by the handler,
      not user-alterable. Values are:

      Disk drives  Dl - D4   49-52   ($31-$34)
      Printer      P1           64       ($40)
      Printer      P2           79       ($4F)
      RS232 ports  R1-R4     80-83   ($50-$53)


 769             301             DUNIT

      Disk or device unit number: one to four, set up by the user.


 770             302             DCOMND

      The number of the disk or device operation (command) to be
      performed, set by the user or by the device handler prior to
      calling SIO. Serial bus commands are:

      Read             82    ($52)
      Write (verily)   87    ($57)
      Status           83    ($53)
      Put (no verify)  80    (0)
      Format           33    ($21)
      Download         32    ($20)
      Read address     84    ($54)
      Read spin        81    ($51)
      Motor on         85    ($55)
      Verify sector    86    ($56)

      All of the above are disk device commands, except write and
      status, which are also printer commands (with no verify).


 771             303             DSTATS

      The status code upon return to user. Also used to set the data
      direction; whether the device is to send or receive a data frame.
      This byte is used by the device handler to indicate to SIO what to
      do after the command frame is sent and acknowledged. Prior to
      the SIO call, the handler examines BIT 6 (one equals receive
      data) and BIT 7 (one equals send data). If both bits are zero, then
      no data transfer is associated with the operation. Both bits set to
      one is invalid. SIO uses it to indicate to the handler the status of
      the requested operation after the SIO call.


 772,773                 304,305                 DBUFLO/HI

      Data buffer address of the source or destination of the data to be
      transferred or the device status information (or the disk sector
      data). Set by the user, it need not be set if there is no data
      transferred, as in a status request.


 774             306             DTIMLO

      The time-out value for the handler in one-second units, supplied
      by the handler for use by SIO. The cassette time-out value is 35,
      just over 37 seconds. The timer values are 64 seconds per 60 units
      of measurement. Initialized to 31.


 775             307             DUNUSE

      Unused byte.


 776,777                 308,309                 DBYTLO/HI

      The number of bytes transferred to or from the data buffer (or the
      disk) as a result of the most recent operation, set by the handler.
      Also used for the count of bad sector data. There is a small bug in
      SIO which causes incorrect system actions when the last byte in a
      buffer is in a memory location ending with $FF, such as $A0FF.


 778,779                 30A,30B                 DAUX1/2

      Used for device specific information such as the disk sector
      number for the read or write operation. Loaded down to locations
      572, 573 ($23C, $23D) by SIO.

      There are only five commands supported by the disk handler:
      GET sector (82; $52), PUT sector (80; $50), PUT sector with
      VERIFY (87; $57), STATUS request (83; $53) and FORMAT entire
      disk (33; $21). There is no command to FORMAT a portion of the
      disk; this is done by the INS 1771-1 formatter/controller chip in
      the drive itself and isn't user-accessible. There is a new disk drive
      ROM to replace the current "C" version. It is the "E" ROM. Not
      only is it faster than the older ROMs, but it also allows for
      selective formatting of disk sectors. Atari has not announced yet
      whether this new 810 ROM will be made available. For more
      information, see the OS User's Manual.

 Locations 780 to 793 ($30C to $319) are for miscellaneous use.
 Locations 794 to 831 ($31A to $33F) are handler address tables. To use
 these DCBs, the user must provide the required parameters to this
 block and then do a machine language JSR to $E453 (58451) for disk
 I/O or $E459 (58457; the SIO entry point) for other devices.


 780,781                 30C,30D                 TIMER1

      Initial baud rate timer value.


 782             30E             ADDCOR

      Addition correction flag for the baud rate calculations involving
      the timer registers.


 783             30F             CASFLG

      Cassette mode when set. Used by SIO to control the program
      flow through shared code. When set to zero, the current
      operation is a standard SIO operation; when non-zero, it is a
      cassette operation.


 784,785                 310,311                 TIMER2

      Final timer value. Timer one and timer two contain reference
      times for the start and end of the fixed bit pattern receive period.
      The first byte of each timer contains the VCOUNT value (54283;
      $D40B), and the second byte contains the current realtime clock
      value from location 20 ($14). The difference between the timer
      values is used in a lookup table to compute the interval for the
      new values for the baud rate passed on to location 750, 751
      ($2EE, $2EF).


 786,787                 312,313                 TEMP1

      Two-byte temporary storage register used by SIO for the
      VCOUNT calculation during baud timer routines. See location
      54283 ($D40B).


 788             314             TEMP2

      Temporary storage register.


 789             315             TEMP3

      Ditto.


 790             316             SAVIO

      Save serial data-in port used to detect, and updated after, each
      bit arrival. Used to retain the state of BIT 4 of location 53775
      ($D20F; serial data-in register).


 791             317             TIMFLG

      Time-out flag for baud rate correction, used to define an
      unsuccessful baud rate value. Initially set to one, it is
      decremented during the I/O operation. If it reaches zero (after
      two seconds) before the first byte of the cassette record is read,
      the operation will be aborted.


 792             318             STACKP

      SIO stack pointer register. Points to a byte in the stack being
      used in the current operation (locations 256 to 511; $100 to $1FF).


 793             319             TSTAT

      Temporary status holder for location 48 ($30).


 794-831                 31A-33F                 HATABS

      Handler Address Table. Thirty-eight bytes are reserved for up to
      12 entries of three bytes per handler, the last two bytes being set
      to zero. On powerup, the HATABS table is copied from ROM.
      Devices to be booted, such as the disk drive, add their handler
      information to the end of the table. Each entry has the character
      device name (C,D,E,K,P,S,R) in ATASCII code and the handler
      address (LSB/MSB). Unused bytes are all set to zero. FMS
      searches HATABS from the top for a device "D:" entry, and when
      it doesn't find it, it then sets the device vector at the end of the
      table to point to the FMS vector at 1995 ($7CB). CIO searches for
      a handler character from the bottom up. This allows new handlers
      to take precedence over the old. Pressing RESET clears HATABS
      of all but the resident handler entries!

      794   31A   Printer device ID (P:), initialized to 58416 ($E430).
      797   31D   Cassette device ID (C:), initialized to 58432 ($E440).
      800   320   Display editor ID (E:), initialized to 58368 ($E400).
      803   323   Screen handler ID (S:), initialized to 58384 ($E410).
      806   326   Keyboard handler ID (K:), initialized to 58400
                  ($E420).

      HATABS unused entry points:
      809 ($329), 812 ($32C), 815 ($32F), 818 ($332), 821 ($335), 824
      ($338), 827 ($33B), and 830 ($33E). These are numbered
      sequentially from one to eight. There are only two bytes in the last
      entry (unused), both of which are set to zero. When DOS is
      present, it adds an entry to the table with the ATASCII code for
      the letter "D" and a vector to address 1995 ($7CB).

      The format for the HATABS table is:

      Device name
      Handler vector table address
      More entries
      Zero fill to the end of the table

      The device handler address table entry above for the specific
      handler points to the first byte (low byte/high byte) of the vector
      table which starts at 58368 ($E400). Each handler is designed
      with the following format:

      OPEN vector
      CLOSE vector
      GET BYTE vector
      PUT BYTE vector
      GET STATUS vector
      SPECIAL vector
      Jump to initialization code (JMP LSB/MSB)

      CIO uses the ZIOCB (see location 32; $20) to pass parameters to
      the originating IOCB, the A, Y and X registers and CIO. It is
      possible to add your own device driver(s) to OS by following
      these rules:
      1) Load your routine, with necessary buffers at the address
         pointed to by MEMLO: location 743 ($2E7).
      2) Add the size of your routine to the MEMLO value and POKE
         the result back into MEMLO.
      3) Store the name and address of your driver in the handler
         address table; HATABS.
      4) Change the vectors so that the OS will re-execute the above
         steps if RESET has been pressed. This is usually done by
         adjusting locations 12 ($C: DOSINIT) and 10 ($A; DOSVEC).
 
      See the "Insight: Atari" columns in COMPUTE!, January and
      April 1982, for details. The APX program "T: A Text Display
      Device" is a good example of a device handler application.
      See De Re Atari for more information on the DCB and HATABS,
      including the use of a null handler.

 ---------------------------------------------------------------------------
 Locations 832 to 959 ($340 to $3BF) are reserved for the eight IOCB's
 (input/output control blocks). IOCB's are channels for the transfer of
 information (data bytes) into and out of the Atari, or between devices.
 You use them to tell the computer what operation to perform, how
 much data to move and, if necessary, where the data to be moved is
 located. Each block has 16 bytes reserved for it.

 What is an IOCB? Every time you PRINT something on the screen or
 the printer, every time you LOAD or SAVE a file, every time you OPEN
 a channel, you are using an IOCB. In some cases, operations have
 automatic OPEN and CLOSE functions built in--like LPRINT. In
 others, you must tell the Atari to do each step as you need it. Some
 IOCB's are dedicated to specific use, such as zero for the screen
 display. Others can be used for any I/O function you wish. The
 information you place after the OPEN command tells CIO how you
 want the data transferred to or from the device. It is SIO and the device
 handlers that do the actual transfer of data.
 You can easily POKE the necessary values into the memory locations
 and use a machine language subroutine through a USR function to call
 the CIO directly (you must still use an OPEN and CLOSE statement for
 the channel, however). This is useful because BASIC only supports
 either record or single byte data transfer, while the CIO will handle
 complete buffer I/O. See the CIO entry address, location 58454
 ($E456), for more details. These blocks are used the same way as the
 page zero IOCB (locations 32 to 47; $20 to $2F). The OS takes the
 information here, moves it to the ZIOCB for use by the ROM CIO, then
 returns the updated information back to the user area when the
 operation is done.
 Note that when BASIC encounters a DOS command, it CLOSEs all
 channels except zero. Refer to the Atari Hardware Manual and the 850
 Interface Manual for more detailed use of these locations.


 832-847                 340-34F                 IOCB0

      I/O Control Block (IOCB) zero. Normally used for the screen
      editor (E:). You can POKE 838,166 and POKE 839,238 and send
      everything to the printer instead of to the screen (POKE 838,163,
      and POKE 839,246 to send everything back to the screen again).
      You could use this in a program to toggle back and forth between
      screen and printed copy when prompted by user input. This will
      save you multiple PRINT and LPRINT coding.

      You can use these locations to transfer data to other devices as
      well since they point to the address of the device's "put one byte"
      routine. See the OS Manual for more information. Location 842
      can be given the value 13 for read from screen and 12 for write to
      screen. POKE 842,13 puts the Atari into "RETURN key mode" by
      setting the auxiliary byte one (ICAX1) to screen input and
      output. POKEing 842 with 12 returns it to keyboard input and
      screen output mode. The former mode allows for dynamic use of
      the screen to act upon commands the cursor is made to move
      across.

      You can use this "forced read" mode to read data on the screen
      into BASIC without user intervention. For example, in the
      program below, lines 100 through 200 will be deleted by the
      program itself as it runs.

      10 GRAPHICS 0:POSITlON 2,4
      20 PRINT 100:PRINT 150:PRINT 200
      25 PRINT "CONT"
      30 POSITION 2,0
      50 POKE 842,13:STOP
      60 POKE 842,12
      70 REM THE NEXT LINES WILL BE DELETED
      100 PRINT "DELETING..."
      150 PRINT "DELETING..."
      200 PRINT "DELETED!"
     
      DOWNLOAD FORCREAD.BAS

      See COMPUTE!, August 1981, for a sample of this powerful
      technique. See Santa Cruz's Tricky Tutorial #1 (display lists) for
      another application. The last four bytes (844 to 847; $34C to $34F
      in this case) are spare (auxiliary) bytes in all IOCB's.
      When you are in a GRAPHICS mode other than zero, channel
      zero is OPENed for the text window area. If the window is absent
      and you OPEN channel zero, the whole screen returns to mode
      zero. A BASIC NEW or RUN command closes all channels
      except zero. OPENing a channel to S: or E: always clears the
      display screen.
      See COMPUTE!, October 1981,for an example of using an IOCB
      with the cassette program recorder, and September 1981 for
      another use with the Atari 825 printer.


 848-863                 350-35F                 IOCB1

      IOCB one.


 864-879                 360-36F                 IOCB2

      IOCB two.


 880-895                 370-37F                 IOCB3

      IOCB three.


 896-911                 380-38F                 IOCB4

      IOCB four.


 912-927                 390-39F                 IOCB5

      IOCB five.


 928-943                 3A0-3AF                 IOCB6

      IOCB six. The GRAPHICS statement OPENs channel six for
      screen display (S:), so once you are out of mode zero, you cannot
      use channel six unless you first issue a CLOSE#6 statement. If
      you CLOSE this channel, you will not be able to use the
      DRAWTO, PLOT or LOCATE commands until you reOPEN the
      channel. The LOAD command closes channel six; it also closes
      all channels except zero.


 944-959                 3B0-3BF                 IOCB7

      IOCB seven. LPRINT automatically uses channel seven for its
      use. If the channel is OPEN for some other use and an LPRINT is
      done, an error will occur, the channel will be CLOSEd, and
      subsequent LPRINTs will work. The LIST command also uses
      channel seven, even if channel seven is already OPEN. However,
      when the LIST is done, it CLOSEs channel seven. The LOAD
      command uses channel seven to transfer programs to and from
      the recorder or disk. LIST (except to the display screen), LOAD
      and LPRINT also close all sound voices. The RUN from tape or
      disk and SAVE commands use channel seven, as does LIST.
      The bytes within each IOCB are used as follows:

      Label     Offset  Bytes Description
      --------------------------------------------------------------------
      ICHID     0       1     Index into the device name
      table for the currently OPEN file. Set by the OS. If not in use, the
      value is 255 ($FF), which is also the initialization value.
     
      ICDNO     1       1     Device number such as one
      for Dl: or two for D2:. Set by the OS.

      ICCOM     2       1     Command for the type of
      action to be taken by the device, set by the user. This is the first
      variable after the channel number in an OPEN command. See
      below for a command summary. Also called ICCMD.

      ICSTA     3       1     The most recent status
      returned by the device, set by the OS. May or may not be the
      same value as that which is returned by the STATUS request in
      BASIC. See the OS User's Manual, pp. 165-166, fora list of status
      byte values.

      ICBAL/H   4,5     2     Two-byte (LSB,MSB) buffer
      address for data transfer or the address of the file name for OPEN,
      STATUS, etc.

      ICPTL/H   6,7     2     Address of the device's put-
      one-byte routine minus one. Set by the OS at OPEN command,
      but not actually used by the OS (it is used by BASIC, however).
      Points to CIO's "IOCB NOT OPEN" message at powerup.

      ICBLL/H   8,9     2     Buffer length set to the
      maximum number of bytes to transfer in PUT and GET
      operations. Decremented by one for each byte transferred;
      updated after each READ or WRITE operation. Records the
      number of bytes actually transferred in and out of the buffer after
      each operation.

      ICAX1     10      1     Auxiliary byte number one,
      referred to as AUX1. Used in the OPEN statement to specify the
      type of file access: four for READ, eight for WRITE, twelve for
      both (UPDATE). Not all devices can use both kinds of operations.
      This byte can be used in user-written drivers for other purposes
      and can be altered in certain cases once the IOCB has been
      OPENed (see the program example above). For the S: device, if
      AUX1 equals 32, it means inhibit the screen clear function when
      changing GRAPHICS modes. Bit use is as follows for most
      applications:
      Bit  7   6   5   4   3   2   1   0
      Use  ....unused....  W   R   D   A

      W equals write, R equals read, D equals directory, A equals
      append.

      ICAX2     11      1     Auxiliary byte two, referred
      to as AUX2. Special use by each device driver; some serial port
      functions may use this byte. Auxiliary bytes two to five have no
      fixed use; they are used to contain device-dependent and/or
      user-established data.

      ICAX3/4   12,13   2     Auxiliary bytes three and
      four; used to maintain a record of the disk sector number for the
      BASIC NOTE and POINT commands.

      ICAX5     14      1     Auxiliary byte five. Used by
      NOTE and POINT to maintain a record of the byte within a sector.
      It stores the relative displacement in sector from zero to 124
      ($7C). Bytes 125 and 126 of a sector are used for sector-link
      values, and byte 127 ($7F) is used as a count of the number of
      data bytes in actual use in that sector.

      ICAX6     15      1     Spare auxiliary byte.

      Offset is the number you would add to the start of the IOCB in
      order to POKE a value into the right field, such as POKE 832 +
      OFFSET, 12.

      The following is a list of the values associated with OPEN
      parameter number 1. Most of these values are listed in Your Atari
      400/800. These are the values found in ICAX1, not the ICCOM
      values.

      Device        Task #    Description
      ----------------------------------------------------------------------
      Cassette       4        Read
      recorder       8        Write (can do either, not both)

      Disk           4        Read
      file           6        Read disk directory
                     8        Write new file. Any file OPENed in
      this mode will be deleted, and the first byte written will be at the
      start of the file.
                     9        Write--append. In this mode the
      file is left intact, and bytes written are put at the end of the file.
                    12        Read and write--update. Bytes
      read or written will start at the first byte in the file.

      D: if BIT 0 equals one and BIT 3 equals one in AUX1,then
      operation will be appended output.

      Screen         8        Screen output
      editor        12        Keyboard input and screen output
      (E:)          13        Screen input and output

      E: BIT 0 equals one is a forced read (GET command).

      Keyboard       4        Read

      Printer        8        Write

      RS-232         5        Concurrent read
      serial         8        Block write
      port           9        Concurrent write
                    13        Concurrent read and write

                              Clear      Text      Read
                              Screen     Window    Oper-
                              after GR.  also      ation

      Screen         8        yes        no        no
      display       12        yes        no        yes
      (S:)          24        yes        yes       no
                    28        yes        yes       yes
                    40        no         no        no
                    44        no         no        yes
                    56        no         yes       no
                    60        no         yes       yes

      Note that with S:, the screen is always cleared in GR.0 and there
      is no separate text window in GR.0 unless specifically user-
      designed. Without the screen clear, the previous material will
      remain on screen between GRAPHICS mode changes, but will
      not be legible in other modes. The values with S: are placed in
      the first auxiliary byte of the IOCB. All of the screen values above
      are also a write operation.

      The second parameter in an OPEN statement (placed in the
      second auxiliary byte) is far more restricted in its use. Usually set
      to zero. If set to 128 ($80) for the cassette, it changes from normal
      to short inter-record gaps (AUX2).

      With the Atari 820 printer, 83 ($53; AUX byte two) means
      sideways characters (Atari 820 printer only). Other printer
      variables (all for AUX2 as well) are: 70 ($4E) for normal 40
      character per line printing and 87 ($57) for wide printing mode.
      With the screen (S:), a number can be used to specify the
      GRAPHICS modes zero through eleven. If mode zero is chosen,
      then the AUX1 options as above are ignored.
      For the ICCOM field, the following values apply (BASIC XIO
      commands use the same values):

      Command                       Decimal   Hex
      ----------------------------------------------------------------------
      Open channel                      3       3
      Get text record (line)            5       5   BASIC:
                                                    INPUT
                                                    #n,A
      Get binary record (buffer)        7       7   BASIC:
                                                    GET #n,A
      Put text record (line)            9       9
      Put binary record (buffer)       11       B   BASIC:
                                                    PUT #n,A
      Close                            12       C
      Dynamic (channel) status         13       D

      BASIC uses a special "put byte" vector in the IOCB to talk
      directly to the handler for the PRINT#n,A$ command.
      Disk File Management System Commands (BASIC XIO
      command):

      Rename                           32      20
      Erase (delete)                   33      21
      Protect (lock)                   35      23
      Unprotect (unlock)               36      24
      Point                            37      25
      Note                             38      26
      Format                          254      FE

      In addition, XIO supports the following commands:

      Get character                     7       7
      Put character                    11       B
      Draw line                        17      11   Display
                                                    handler
                                                    only.
      Fill area                        18      12   Display
                                                    handler
                                                    only.

      FILL is done in BASIC with XIO 18,#6,12,0,"S:" (see the BASIC
      Reference Manual for details).

      For the RS-232 (R:), XIO supports:

      Output partial block             32      20
      Control RTS,XMT,DTR              34      22
      Baud, stop bits, word size       36      24
      Translation mode                 38      26
      Concurrent mode                  40      28

      (see the 850 Interface Manual for details)

      CIO treats any command byte value greater than 13 ($D) as a
      special case, and transfers control over to the device handler for
      processing. For more information on IOCB use, read Bill
      Wilkinson's "Insight: Atari" columns in COMPUTE!, November
      and December 1981, and in Microcomputing, August 1982. Also
      refer to the OS User's Manual and De Re Atari.

 ---------------------------------------------------------------------------

 960-999                 3C0-3E7                 PRNBUF

      Printer buffer. The printer handler collects output from LPRINT
      statements here, sending them to the printer when an End of Line
      (EOL; carriage return) occurs or when the buffer is full. Normally
      this is 40 characters. However, if an LPRINT statement generates
      fewer than 40 characters and ends with a semicolon or 38
      characters and ends with a comma, Atari sends the entire buffer
      on each FOR-NEXT loop, the extra bytes filled with zeros. The
      output of the next LPRINT statement will appear in column 41 of
      the same line. According to the Operating System User's
      Manual, the Atari supports an 80-column printer device called
      P2:. Using OPEN and PUT statements to P2: may solve this
      problem. Here is a small routine for a GR.0 BASIC screen dump:

      10  DIM TEXT$(1000): OPEN#2,4,0,"S:":
          TRAP 1050
      .
      .
      .
      1000  FOR LINE = 1 TO 24: POSITION PE
           EK(82),LINE
      1010  FOR COL = 1 TO 38: GET#2,CHAR:
           TEXT$(COL,COL)=CHR$(CHAR)
      1020  NEXT COL: GET#2,COL
      1030  LPRINT TEXT$
      1040  NEXT LINE
      1050  RETURN

      You can use the PTABW register at location 201 ($C9) to set the
      number of spaces between print elements separated by a comma.
      The minimum number of spaces accepted is two. LPRINT
      automatically uses channel seven for output. No OPEN statement
      is necessary and CLOSE is automatic.

 ---------------------------------------------------------------------------
 Locations 1000 to 1020 ($3E8 to $3FC) are a reserved spare buffer
 area.


 1021-1151               3FD-47F                 CASBUF

      Cassette buffer. These locations are used by the cassette handler
      to read data from and write data to the program (tape) recorder.
      The 128 ($80) data bytes for each cassette record are stored
      beginning at 1024 ($400 - page four). The current buffer size is
      found in location 650 ($28A). Location 61 ($3D) points to the
      current byte being written or read.
      CASBUF is also used in the disk boot process; the first disk
      record is read into this buffer.

      A cassette record consists of 132 bytes: two control bytes set to 85
      ($55; alternating zeros and ones) for speed measurement in the
      baud rate correction routine; one control byte (see below); 128
      data bytes (compared to 125 data bytes for a disk sector), and a
      checksum byte. Only the data bytes are stored in the cassette
      buffer. See De Re Atari for more ~nformaUon on the cassette
      recorder.



 CONTROL BYTE VALUES

 Value      Meaning
 250 ($FA)  Partial record follows. The actual number of bytes is stored
            in the last byte of the record (127).
 252 ($FC)  Record full; 128 bytes follow.
 254 ($FE)  End of File (EOF) record; followed by 128 zero bytes.

 ---------------------------------------------------------------------------
 Locations 1152 to 1791 ($480 to $6FF) are for user RAM (outer
 environment) requirements, depending on the amount of RAM
 available in the machine. Provided you don't use the FP package or
 BASIC, you have 640 ($280) free bytes here.
 Locations 1152 to 1279 ($480 to $4FF) are 128 ($80) spare bytes.
 The floating point package, when used, requires locations 1406 to 1535
 ($57E to $5FF).


 1406            57E             LBPR1

      LBUFF prefix one.


 1407            57F             LBPR2

      LBUFF prefix two.


 1408-1535               580-5FF                 LBUFF

      BASIC line buffer; 128 bytes. Used as an output result buffer for
      the FP to ASCII routine at 55526 ($D8E6). The input buffer is
      pointed to by locations 243, 244 ($F3, $F4).


 1504            5E0             PLYARG

      Polynomial arguments (FP use).


 1510-1515               5E6-5EB                 FPSCR

      FP scratch pad use.


 1516-1535               5EC-5FF                 FPSCR1

      Ditto. The end of the buffer is named LBFEND.

 ---------------------------------------------------------------------------

 1536-1791               600-6FF                 ....

      Page six: 256 ($FF) bytes protected from OS use. Page six is not
      used by the OS and may be safely used for machine language
      subroutines, special I/O handlers, altered character sets, or
      whatever the user can fit into the space. Some problem may arise
      when the INPUT statement retrieves more than 128 characters.
      The locations from 1536 to 1663 ($600 to $67F) are then
      immediately used as a buffer for the excess characters. To avoid
      overflow, keep INPUT statements from retrieving more than 128
      characters. The valFORTH implementation of fig-FORTH (from
      ValPar International) uses all of page six for its boot code, so it is
      not available for your use. However, FORTH allows you to
      reserve other blocks of memory for similar functions. BASIC A+
      uses locations $0600 - $67F.

 ---------------------------------------------------------------------------
      Locations 1792 to the address specified by LOMEM (locations
      128, 129; ($80, $81) - the pointer to BASIC low memory) are also
      used by DOS and the File Management System (FMS). Refer to
      the DOS source code and Inside Atari DOS for details. The
      addresses which follow are those for DOS 2.0S, the official Atari
      DOS at the time of this writing. Another DOS is available as an
      alternative to DOS 2.0 -- K-DOS (TM), from K-BYTE (R). K-DOS
      is not menu driven but command driven. It does not use all of the
      same memory locations as the Atari DOS although it does use a
      modified version of the Atari FMS. (Another command-driven
      DOS, called OS/A+, is completely compatible with DOS 2.OS
      and is available from OSS, the creators of DOS 2.0S.)


 1792-5377      700-1501

      File management system RAM (pages seven to fifteen). FMS
      provides the interface between BASIC or DUP and the disk
      drive. It is a sophisticated device driver for all I/O operations
      involving the D: device. It allows disk users to use the special
      BASIC XIO disk commands (see the IOCB area 832 to 959: $340
      to $3BF). It is resident in RAM below your BASIC RAM and
      provides the entry point to DOS when called by BASIC.


 5440-13062     1540-3306

      DUP.SYS RAM. The top will vary with the amount of buffer
      storage space allocated to the drive and sector buffers.


 6780-7547      1A7C-1D7B

      Drive buffers and sector-data buffers. The amount of memory will
      vary with the number of buffers allocated.


 7548-MEMLO     1D7C-3306 (maximum)

      Non-resident portion of DUP.SYS, DOS utility routines. DUP
      provides the utilities chosen from the DOS menu page, not from
      BASIC. It is not resident in RAM when you are using BASIC or
      another cartridge; rather it is loaded when DOS is called from
      BASIC or on autoboot powerup (and no cartridge supersedes it).
      When DUP is loaded, it overwrites the lower portion of memory.
      If you wish to save your program from destruction, you must have
      created a MEM.SAV file on disk before you called DOS from your
      program. See the DOS Reference Manual.

 ---------------------------------------------------------------------------
 Locations 1792 to 2047 ($700 to $7FF; page seven) are the user boot
 area. MEMLO and LOMEM point to 1792 when no DOS or DUP
 program is loaded. This area can then be used for your BASIC or
 machine language programs. The lowest free memory address is 1792,
 and programs may extend upwards from here. There is a one-page
 buffer before the program space used for the tokenization of BASIC
 statements, pointed to by locations 128, 129 ($80, $81). Actually a
 program may start from any address above 1792 and below the screen
 display list as long as it does not overwrite this buffer if it is a BASIC
 program. Also, 1792 is the start of the FMS portion of DOS when
 resident.

 When software is booted, the MEMLO pointer at 743,744 ($2E7,$2E8)
 in the OS data base (locations 512 to 1151; $512 to $47F) points to the
 first free memory location above that software; otherwise, it points to
 1792. The DUP portion of DOS is partly resident here, starting at 5440
 ($1540) and running to 13062 ($1540 to $3306). The location of the OS
 disk boot entry routine (DOBOOT) is 62189 ($F2ED). The standard
 Atari DOS 2.OS takes up sectors one through 83 ($53) on a disk. Sector
 one is the boot sector. Sectors two through 40 ($28) are the FMS
 portion, and sectors 41 ($29) through 83 are the DUP.SYS portion of
 DOS. For more information, see the DOS and OS source listings and
 Inside Atari DOS.

 ---------------------------------------------------------------------------

 FMS, DOS.SYS and DUP.SYS

      Disk boot records (sector one on a disk) are read into 1792 ($700).
      Starting from $700 (1792), the format is:

      Byte    Hex       Label and use
      0       700       BFLAG: Boot flag equals zero (unused).
      1       701       BRCNT: Number of consecutive sectors to
                        read (if the file is DOS, then BRCNT equals
                        one).
      2,3     702,703   BLDADR: Boot sector load address ($700).
      4,5     704,705   BIWTARR: Initialization address.
      6       706       JMP XBCONT: Boot continuation vector; $4C
      (76): JMP command to next address in bytes seven and eight.

      7,8     707,708   Boot read continuation address
      (LSB/MSB).

      9       709       SABYTE: Maximum number of concurrently
      OPEN files. The default is three (see 1801 below).

      10      70A       DRVBYT: Drive bits: the maximum number
      of drives attached to the system. The default is two (see 1802
      below).

      11      70B       (unused) Buffer allocation direction, set to
      zero.

      12,13   70C,70D   SASA: Buffer allocation start address. Points
      to 1995 ($7CB) when DOS is loaded.

      14      70E       DSFLG: DOS flag. Boot flag set to non-zero
      Must be non-zero for the second phase of boot process. Indicates
      that the file DOS.SYS has been written to the disk; zero equals no
      DOS file, one equals 128 byte sector disk, two equals 256 byte
      sector disk.

      15,16   70F,710   DFLINK: Pointer to the first sector of DOS.SYS
      file.

      17      711       BLDISP: Displacement to the sector link byte
      125 ($7D). The sector link byte is the pointer to the next disk
      sector to be read. If it is zero, the end of the file has been
      reached.

      18,19   712,713   DFLADR: Address of the start of DOS.SYS
      file.

      20+     714+      Continuation of the boot load file. See the
      OS User's Manual and Chapter 20 of Inside Atari DOS.

      Data from the boot sector is placed in locations 1792 to 1916 ($700
      to $77C). Data from the rest of DOS.SYS is located starting from
      1917 ($77D). All binary file loads start with 255 ($FF). The next
      four bytes are the start and end addresses (LSB/MSB),
      respectively.


 1801            709             SABYTE

      This records the limit on the number of files that can be open
      simultaneously. Usually set to three, the maximum is seven (one
      for each available IOCB -- remember IOCB0 is used for the
      screen display). Each available file takes 128 bytes for a buffer,
      if you increase the number of buffers, you decrease your RAM
      space accordingly. You can POKE 1801 with your new number to
      increase or decrease the number of files and then rewrite DOS
      (by calling DOS from BASIC and choosing menu selection "H")
      and have this number as your default on the new DOS.


 1802            70A             DRVBYT

      The maximum number of disk drives in your system, the DOS 2.0
      default value is two. The least four bits are used to record which
      drives are available, so if you have drives one, three and four,
      this location would read:

      00001101 or 13 in decimal.

      Each drive has a separate buffer of 128 bytes reserved for it in
      RAM. If you have more or less than the default (two), then POKE
      1802 with the appropriate number:

      1 drive  =  1 BIT 0                Binary 00000001
      2 drives =  3 BITS 0 & 1                  00000011
      3 drives =  7 BITS 0, 1 & 2               00000111
      4 drives = 15 BITS 0, 1, 2 & 3            00001111

      This assumes you have them numbered sequentially. If not,
      POKE the appropriate decimal translation for the correct binary
      code: each drive is specified by one of the least four bits from one
      in BIT 0 to four in BIT 3. If you PEEK (1802) and get back three,
      for example, it means drives one and two are allocated, not three
      drives.

      You can save your modification to a new disk by calling up DOS
      and choosing menu selection "H." This new DOS will then boot
      up with the number of drives and buffers you have allocated. A
      one-drive system can save 128 bytes this way (256 if one less data
      buffer is chosen). See the DOS Manual, page G.87.


 1900            76C             BSIO

      Entry point to FMS disk sector I/O routines.


 1906            772             BSIOR

      Entry point to the FMS disk handler (?).


 1913            779             ....

      Write verify flag for disk I/O operations. POKE with 80 ($50) to
      turn off the verify function, 87 ($57) to turn it back on. Disk write
      without verify is faster, but you may get errors in your data. I
      have had very few errors generated by turning off the verify
      function, but even one error in critical material can destroy a
      whole program. Be careful about using this location. You can
      save DOS (as above with menu selection "H") without write verify
      as your new default by writing DOS to a new disk. See the DOS
      Manual, page F.85. K-DOS's write-verify flag is located at 1907
      ($773).


 1995            7CB             DFMSDH

      Entry point to a 21-byte FMS device (disk) handler. The address
      of this handler is placed in HATABS (locations 794 to 831; $31A
      to $33F) by the FMS initialization routine. When CIO needs to
      call an FMS function, it will locate the address of that function via
      the handler address table. See Chapters 8-11 of Inside Atari
      DOS, published by COMPUTE! Books.


 2016            7E0             DINT

      FMS initialization routine. The entry point is 1995 ($7CB). DUP
      calls FMS at this point. K-DOS uses the same location for its
      initialization routine.


 2219            8AB             DFMOPN

      OPEN routines, including open for append, update, and output.


 2508            900             DFMPUT

      PUT byte routines.


 2591            A1F             WTBUR

      Burst I/O routines.


 2592-2773               A20-AD5                 ....

      In COMPUTE!, May and July 1982, Bill Wilkinson discussed
      BURST I/O, which should not take place when a file is OPEN for
      update, but does, due to a minor bug in DOS 2.0 (see also Inside
      Atari DOS, Chapter 12). This will cause update writes to work
      properly, but update reads to be bad. The following POKEs will
      correct the problem. Remember to save DOS back to a new disk.

      POKE 2592,130         ($A20,82)
      POKE 2593,19          ($A21,13)
      POKE 2594,73          ($A22,49)
      POKE 2595,12          ($A23,0C)
      POKE 2596,240         ($A24,F0)
      POKE 2597,36          ($A25,24)
      POKE 2598,106         ($A26,6A)
      POKE 2599,234         ($A27,EA)
      POKE 2625,16          ($A41,10)
      POKE 2773,31          ($AD5,1F)

      (Note that the July 1982 issue of COMPUTE! contained a typo
      where the value to be POKEd into 2773 was mistakenly listed as
      13, not 31!) Wilkinson points out that one way to completely
      disable BURST I/O (useful in some circumstances such as using
      the DOS BINARY SAVE to save the contents of ROM to disk!) is
      by:

      POKE 2606,0           ($A2E,0)

      This, however, will make the system LOAD and SAVE files
      considerably more slowly, so it's not recommended as a
      permanent change to DOS.


 2751            ABF             DFMGET

      GET byte routines, including GET file routines.

 2817           B0l            DFMSTA
      Disk STATUS routines.


 2837            B15             DFMCLS

      IOCB CLOSE routines.


 2983            BA7             DFMDDC

      Start of the device-dependent command routines, including the
      BASIC XIO special commands:


 3033            BD9             XRENAME

      RENAME a file.


 3122            C32             XDELETE

      DELETE a file.


 3196            C7C             XLOCK, XUNLOCK

      LOCK and UNLOCK files. UNLOCK routines begin at 3203
      ($C83).


 3258            CBA             XPOINT

      BASIC POINT command.


 3331            D03             XNOTE

      BASIC NOTE command. See the DOS Manual for information
      regarding these two BASIC commands, and see De Re Atari for a
      sample use.


 3352            D18             XFORMAT

      Format the entire diskette.


 3501            DAD             LISTDIR

      List the disk directory.


 3742            E9E             FNDCODE

      File name decode, including wildcard validity test. The current
      file name is pointed to by ZBUFP at locations 67, 68 ($43, $44).


 3783            EC7             ....

      By POKEing the desired ATASCII value here, you can change
      the wildcard character (*; ATASCII 42, $2A) used by DOS to any
      other character of your choice. Your altered DOS can be saved
      back to disk with DOS menu selection "H".


 3818,3822               EEA,EEE                 ....

      By POKEing 3818 with 33 and 3822 with 123 ($21 ,$7B;), you can
      modify DOS to accept file names with punctuation, numbers and
      lowercase as valid; 33 is the low range of the ATASCII code and
      127 the high range (lower or higher values are control and
      graphics codes and inverse characters). Of course, any
      unmodified DOS still won't accept such file names. You could
      actually change the range to any value from zero to 255 at your
      discretion. This, however, may cause other problems with such
      ATASCII codes as spaces and the wildcard (*; see above). Can
      be saved back to disk with menu selection "H".


 3850            F0A             FDSCHAR

      Store the file name characters that result from the file name
      decode routines.


 3873            F21             SFDIR

      Directory search routines; search for the user-specified file
      name.


 3988            F94             WRTNXS

      Write data sector routine.


 4111            100F            RDNXTS

      Read data sector routine.


 4206            106E            RDDIR

      Read and write directory sector routines.


 4235            108B            RDVTOC

      Read or write the volume table of contents (VTOC) sectors.


 4293            10C5            FRESECT

      Free sector(s) routine; returns the number of free sectors on a
      disk that are available to the user.


 4358            1106            GETSECTOR

      Get sector routine; retrieves a free sector for use from the disk.


 4452            1164            SETUP

      SETUP -- initialization of the FMS parameters. Prepares FMS to
      deal with the operation to be performed and to access a
      particular file. See Inside Atari DOS, Chapter seven.


 4618            120A            WRTDOS

      Write new DOS.SYS file to disk routine, including new FMS file
      to DOS.SYS file.


 4789            12B5            ERRNO

      Start of the FMS error number table.


 4856-4978               12F8-1372               ....

      Miscellaneous FMS storage area: sector length, drive tape, stack
      level, file number, etc.


 4993-5120               1381-1400               FCB

      Start of the FMS File Control Blocks (FCB's). FCB's are used to
      store information about files currently being processed. The
      eight FCB's are 16-byte blocks that correspond in a one-on-one
      manner with the IOCB's. Each FCB consist of:

      Label    Bytes   Purpose
      FCBFNO   1       File number of the current file being
      processed.

      FCBOTC   1       Which mode the file has been OPENed for:
      append is one, directory read is two, input is four, output is
      eight, update is twelve.

      SPARE    1       Not used.

      FCBSLT   1       Flag for the sector length type; 128 or 256
      bytes

      FCBFLG   1       Working flag. If equal to 128 ($80), then the
      file has been OPENed for output or append and may acquire new
      data sectors. If the value is 64, then sector is in the memory buffer
      awaiting writing to disk.

      FCBMLN   1       Maximum sector data length; 125 or 253 bytes
      depending on drive type (single or double density). The last
      three sector bytes are reserved for sector link and byte count
      data.

      FCBDLN   1       Current byte to be read or modified in the
      operation in a data sector.

      FCBBUF   1       Tell FMS which buffer has been allocated
      to the file being processed.

      FCBCSN   2       Sector number of the sector currently in the
      buffer.

      FCBLSN   2       Number of the next sector in data chain.

      FCBSSN   2       Starting sectors for appended data if the file
      has been OPENed for append.

      FCBCNT   2       Sector count for the current file.

      DUP doesn't use these FCB's; it writes to the IOCB's directly.
      CIO transfers the control to FMS as the operation demands, then
      on to SIO.


 5121            1401            FILDIR

      File directory, a 256 ($100) byte sequential buffer for entries to
      the disk directory.


 5377            1501            ENDFMS

      Disk directory (VTOC -- Volume Table Of Contents) buffer. 64
      ($40) bytes are reserved, one byte for each possible file. It also
      marks the end of FMS. The VTOC (sector 360; $168) is a
      sequential bit map of each of the 720 sectors on the disk. It starts
      at byte ten and continues through to byte 99. When a bit is set
      (one), it indicates that the sector associated is in use.


 5440            1540            DOS

      DUP.SYS initialization address. Beginning of mini-DOS; the
      RAM-resident portion of DUP. Used for the same purpose in K-
      DOS.


 5446,5450               1546,154A               ....

      Contains the location (LSB/MSB) of the DOS VEC (location 10;
      $A). This is the pointer to the address BASIC will jump to when
      DOS is called.


 5533            159D            DUPFLG

      Flag to test if DUP is already resident in memory. Zero equals
      DUP is not there.


 5534            159E            OPT

      Used to store the value of the disk menu option chosen by the
      user.


 5535            159F            LOADFLG

      If this location reads 128, then a memory file (MEM.SAV) file
      doesn't have to be loaded.


 5540            15A4            SFLOAD

      Routines to load a MEM.SAV file if it exists.


 5888            1700            USRDOS

      Listed in the DUP.SYS equates file but never explained in the
      listings.


 5899            170B            MEMLDD

      Flags that the MEM.SAV file has been loaded. Zero means it has
      not been loaded.


 5947            173B            ....

      The MEM.SAV (MEMSAVE) file creation routines begin here.
      They start with the file name MEM.SAV stored in ATASCII
      format. The write routines begin at MWRITE, 5958 ($1746). The
      DOS utility MEMSAVE copies the lower 6000 bytes of memory to
      disk to save your BASIC program from being destroyed when
      you call DOS, which then loads DUP.SYS into that area of
      memory.


 6044,6045               179C-179D               INISAV

      DOSINI (see location 12, 13; $C, $D) vector save location. Entry
      point to DOS on a call from BASIC.


 6046            179E            MEMFLG

      Flag to show if memory has been written to disk using a
      MEM.SAV file.


 6418            1912            CLMJMP

      Test to see if DOS must load MEM.SAV from the disk before it
      does a run at cartridge address, then jumps to the cartridge
      address.


 6432            1920            LMTR

      Test to see if DOS must load MEM.SAV before it performs a run at
      address command from the DOS menu.


 6457            1939            LDMEM

      MEMSAVE load routines (for the MEM.SAV file).


 6518            1979            INITIO

      DUP.SYS warmstart entry. An excellent program to eliminate the
      need for DUP.SYS and MEM.SAV (not to mention the time
      required to load them!) was presented in COMPUTE!, July 1982,
      called MicroDOS; it's well worth examining. See also "The Atari
      Wedge," COMPUTE!, December 1982.

 663C           19E6           ISRODN
      Start of the serial interrupt service routine to output data needed
      routines in DUP.SYS.


 6691            1A23            ISRSIR

      Start of the serial interrupt ready service routines in DUP.SYS.


 6781            1A7D            ....

      Start of the drive and data buffers. Drive buffers are numbered
      sequentially one to four, data buffers one to eight, assuming that
      many are allocated for each. Normally, the first two buffers are
      allocated for drives and the next three for data. Buffers are 128
      ($80) bytes long each and start at 6908 ($1AFC), 7036 ($1B7C),
      7162 ($1BFA) and 7292 ($1C7C). See locations 1801 and 1802
      ($709, $70A).


 7420            1CFC            ....

      MEMLO (743, 744; $2E7, $2E8) points here when DOS is resident
      unless the buffer allocation has been altered. MEMLO will point
      to 7164 for a one drive, two data buffer setup, a saving of 256
      bytes. Loading the RS-232 handler from the 850 Interface will
      move MEMLO up another 1728 bytes. The RS-232 handler in the
      850 Interface will only boot (load into memory) if you first boot
      the AUTORUN.SYS file on your Atari master diskette or use
      another RS-232 boot program such as a terminal package. The
      RS-232 handler will boot up into memory if you do not have a disk
      attached and you have turned it on before turning on the
      computer. You may still use the printer (parallel) port on the 850
      even if the RS-232 handler is not booted.


 7548            1D7C            ....

      Beginning of non-resident portion of DUP; 40 ($28) byte
      parameter buffer.


 7588            1DA4            LINE

      80 ($50) byte line buffer.


 7668            1DF4            DBUF

      256 ($100) byte data buffer for COPY routines. Copy routines
      work in 125-byte passes, equal to the number of data bytes in
      each sector on the disk. There are 256 bytes because Atari had
      planned a double density drive which has 253 data bytes in each
      sector.


 7924            1EF4            ....

      Miscellaneous variable storage area and data buffers.


 7951-8278               1F0F-2056               DMENU

      Disk menu screen display data is stored here.


 8191            1FFF            ....

      This is the top of the minimum RAM required for operation (8K).
      To use DOS, you must have a minimum of 16K.

 ---------------------------------------------------------------------------

 DUP.SYS ROUTINES

 Locations 8192 to 32767 ($2000 to $7FFF) are the largest part of the
 RAM expansion area; this space is generally for your own use. If you
 have DOS.SYS or DUP.SYS loaded in, they also use a portion of this
 area to 13062 ($3306) as below:


 8309            2075            DOSOS

      Start of the DOS utility monitor, including the utilities called
      when a menu selection function is completed and the display of
      the "SELECT ITEM" message.


 8505            2139            DIRLST

      Directory listing.


 8649            21C9            DELFIL

      Delete a file.


 8990            231E            ....

      Copy a file. This area starts with the copy messages. The copy
      routines themselves begin at PYFIL, 9080 ($2378).


 9783            2637            RENFIL

      Rename a disk file routines.


 9856            2680            FMTDSK

      Format the entire disk. There is no way to format specific sectors
      of a disk with the "C" ROMs currently used in your 810 drives.
      There is a new ROM, the "E" version, which not only allows
      selective sector formatting, but is also considerably faster. It was
      not known at the time of this writing whether Atari would release
      the "E" version.


 9966            26EE            STCAR

      Start a cartridge.


 10060           274C            BRUN

      Run a binary file at the user-specified address.


 10111           277F            ....

      Start of the write MEM.SAV file to disk routine. The entry point is
      at MEMSAV, 10138 ($279A).


 10201           27D9            WBOOT

      Write DOS/DUP files to disk.


 10483           28F3            TESTVER2

      Test for version two DOS. DOS.20S is the latest official DOS,
      considerably improved over the earlier DOS 1.0. The S stands for
      single density. Atari had planned to release a dual density drive
      (the 815), but pulled it out of the production line at the last minute
      for some obscure high-level reason. A double density drive is
      available from the Percom company.


 10522           291A            LDFIL

      Load a binary file into memory. If it has a run address specified in
      the file, it will autoboot.


 10608           2970            LKFIL, ULFIL

      Lock and unlock files on a disk.


 10690           29C2            DDMG

      Duplicate a disk.


 11528           2D08            DFFM

      Duplicate a file.


 11841           2E41            ....

      Miscellaneous subroutines.


 12078           2F2E            SAVFIL

      Save a binary file.


 12348           303C            ....

      Miscellaneous subroutines.


 13062           3306            ....

      End of DUP.SYS.
      The rest of RAM is available to location 32767 ($7FFF).

 ---------------------------------------------------------------------------

 CARTRIDGE B: 8K

 Locations 32768 to 40959 ($8000 to $9FFF) are used by the right
 cartridge (Atari 800 only), when present. When not present, this RAM
 area is available for use in programs. When the 8K BASIC cartridge is
 being used, this area most frequently contains the display list and screen
 memory. As of this writing, the only cartridge that uses this slot is
 Monkey Wrench from Eastern House Software.

 It is possible to have 16K cartridges on the Atari by either combining
 both slots using two 8K cartridges or simply having one with large
 enough ROM chips and using one slot. In this case, the entire area from
 32768 to 49151 ($8000 to $BFFF) would be used as cartridge ROM.

 Technically, the right cartridge slot is checked first for a resident
 cartridge and initialized, then the left. You can confirm this by putting
 the Assembler Editor cartridge in the right and BASIC in the left slots.
 BASIC will boot, but not the ASED. Using FRE(0), you will see,
 however, that you have 8K less RAM to use; and PEEKing through this
 area will show that the ASED program is indeed in memory, but that
 control was passed to BASIC. Control will pass to the ASED cartridge if
 the cartridges are reversed. This is because the last six bytes of the
 cartridge programs tell the OS where the program begins -- in both
 cases, it is a location in the area dedicated to the left cartridge. The six
 bytes are as follows:

 Byte                                     Purpose
 Left (A)                     Right(B)
 49146 ($BFFA)             40954 ($9FFA)  Cartridge start address (low byte)
 49147 ($BFFB)             40955 ($9FFB)  Cartridge start address (high byte)
 49148 ($BFFC)             40956,($9FFC)  Reads zero if a cartridge is
      inserted, non-zero when no cartridge is present. This information
      is passed down to the page zero RAM: if the A cartridge is plugged
      in, then location 6 will read one; if the B cartridge is plugged in,
      then location 7 will read one; otherwise they will read zero.
 49149 ($BFFD)             40957 ($9FFD)  Option byte. If BIT 0 equals one,
      then boot the disk (else there is no disk boot). If BIT 2 equals one,
      then initialize and start the cartridge (else initialize but do not
      start). If BIT 7 equals one, then the cartridge is a diagnostic
      cartridge which will take control, but not initialize the OS (else
      non-diagnostic cartridge). Diagnostic cartridges were used by
      Atari in the development of the system and are not available to the
      public.
 49150 ($BFFE)             40958 ($9FFE)  Cartridge initialization address
      low byte.
 49151 ($BFFF)             40959 ($9FFF)  Cartridge initialization address
      high byte. This is the address to which the OS will jump during all
      powerup and RESETs.

      The OS makes temporary use of locations 36876 to 36896 ($900C to
      $9020) to set up vectors for the interrupt handler. See the OS
      listings pages 31 and 81. This code was only used in the
      development system used to design the Atari.

 ---------------------------------------------------------------------------

 CARTRIDGE A: 8K

 Locations 40960 to 49151 ($A000 to $BFFF) are used by the left
 cartridge, when present. When not present, this RAM area is available
 for other use. The display list and the screen display data will be in this
 area when there is no cartridge present.

 Most cartridges use this slot (see above) including the 8K BASIC,
 Assembler-Editor, and many games. Below are some of the entry
 points for the routines in Atari 8K BASIC. There is no official Atari
 listing of the BASIC ROM yet. Many of the addresses below are listed
 in Your Atari 400/800. Others have been provided in numerous
 magazine articles and from disassembling the BASIC cartridge.


 BASIC ROUTINES

 40960-41036    A000-A04C
 Cold start.

 41037-41055    A04D-A05F
 Warm start.

 41056-42081    A060-A461
 Syntax checking routines.

 42082-42158    A462-A4AE
 Search routines.

 42159-42508    A4AF-A60C
 STATEMENT name table. The statement TOKEN list begins at 42161
 ($A4B1). You can print a list of these tokens by:

      5   ADDRESS = 42161
      10  IF NOT PEEK(ADDRESS) THEN PRINT:
         END
      15  PRINT TOKEN,
      20  BYTE = PEEK(ADDRESS): ADDRESS = A
         DDRESS + 1
      30  IF BYTE < 128 THEN PRINT CHR$(BYT
         E);: GOTO 20
      40  PRINT CHR$(BYTE - 128)
      50  ADDRESS = ADDRESS + 2: TOKEN = TO
         KEN + 1: GOTO 10
        
      DOWNLOAD STATMENT.BAS

 42509-43134    A60D-A87E
 Syntax tables. The OPERATOR token list begins at 42979 ($A7E3). You
 can print a list of these tokens by:

      5   ADDRESS = 42979: TOKEN = 16
      10  IF NOT PEEK (ADDRESS) THEN PRINT:
         END
      15  PRINT TOKEN,
      20  BYTE = PEEK(ADDRESS): ADDRESS = A
         DDRESS + 1
      30  IF BYTE < 128 THEN PRINT CHR$(BYT
         E);: GOTO 20
      40  PRINT CHR$(BYTE - 128)
      50  TOKEN = TOKEN + 1
      60  GOTO 10
     
      DOWNLOAD OPERATOR.BAS

 See COMPUTE!, January and February 1982; BYTE, February 1982,
 and De Re Atari for an explanation of BASIC tokens.

 43135-43358    A87F-A95E
 Memory manager.

 43359-43519    A95F-A9FF
 Execute CONT statement.

 43520-43631    AA00-AA6F
 Statement table.

 43632-43743    AA70-AADF
 Operator table.

 43744-44094    AAE0-AC3E
 Execute expression routine.

 44095-44163    AC3F-AC83
 Operator precedence routine.

 44164-45001    AC84-AFC9
 Execute operator routine.

 45002-45320    AFCA-B108
 Execute function routine.

 45321-47127    B109-B817
 Execute statement routine.

 47128-47381    B818-B915
 CONT statement subroutines.

 47382-47542    B916-B9B6
 Error handling routines.

 47543-47732    B9B7-BA74
 Graphics handling routines.

 47733-48548    BA75-BDA4
 I/O routines.

 48549-49145    BDA5-BFF9
 Floating point routines (see below).


 48551           BDA7            SIN

      Calculate SIN(FR0). Checks DEGFLG (location 251; $FB) to see if
      trigonometric calculations are in radians (DEGFLG equals zero)
      or degrees (DEGFLG equals six).


 48561           BDB1            COS

      Calculate Cosine (FR0) with carry. FR0 is Floating Point register
      zero, locations 212-217; $D4-$D9. See the Floating Point package
      entry points from location 55296 on.


 48759           BE77            ATAN

      Calculate Atangent using FR0, with carry.


 48869           BEE5            SQR

      Calculate square root (FR0) with carry.
      Note that there is some conflict of addresses for the above
      routines. The addresses given are from the first edition of De Re
      Atari. The Atari OS Source Code Listing gives the following
      addresses for these FP routines:

      These are entry points, not actual start addresses.

      SIN     48513   ($BD81)
      COS     48499   ($BD73)
      ATAN    48707   ($BE43)
      SQR     48817   ($BEB1)

      However, after disassembling the BASIC ROMs, I found that the
      addresses in De Re Atari appear to be correct.

 49146,7        BFFA,B
      Left cartridge start address.

 49148          BFFC
      A non-zero number here tells the OS that there is no cartridge in
      the left slot.

 49149          BFFD
      Option byte. A cartridge which does not specify a disk boot may
      use all of the memory from 1152 ($480) to MEMTOP any way it sees
      fit.

 49150,1        BFFE,F
      Cartridge initialization address. See the above section on the right
      slot, 32768 to 40959, for more information.

 ---------------------------------------------------------------------------
      When a BASIC program is SAVEd, only 14 of the more than 50
      page zero locations BASIC uses are written to the disk or cassette
      with the program. The rest are all recalculated with a NEW or
      SAVE command, sometimes with RUN or GOTO. These 14
      locations are:

      128,129   80,81    LOMEM
      130,131   82,83    VNTP
      132,133   84,85    VNTD
      134,135   86,87    VVTP
      136,137   88,89    STMTAB
      138,139   8A,8B    STMCUR
      140,141   8C,8D    STARP

      The string/array space is not loaded; STARP is included only to
      point to the end of the BASIC program.
      The two other critical BASIC page zero pointers, which are not
      SAVEd with the program, are:

      142,143   8E,8F    RUNSTK
      144,145   90,91    MEMTOP

      For more information concerning Atari BASIC, see the appendix.
      For detailed description, refer to the Atari BASIC Reference
      Manual. For more technical information, see De Re Atari, BYTE,
      February 1982, and COMPUTE!'s First Book of Atari and
      COMPUTE!'s Second Book of Atari.

 ---------------------------------------------------------------------------
 Locations 49152 to 53247 ($C000 to $CFFF) are unused.
 Unfortunately, this rather large 4K block of memory cannot be written
 to by the user, so it is presently useless. Apparently, this area of ROM
 is reserved for future expansion. Rumors abound about new Atari OS's
 that allow 3-D graphics, 192K of on-board RAM and other delights.
 Most likely this space will be consumed in the next OS upgrade.
 PEEKing this area will show it not to be completely empty; it was
 apparently used for system development in Atari's paleozoic age.
 Although the Atari is technically a 64K machine (1K equals 1024 bytes,
 so 64K equals 65536 bytes), you don't really have all 64K to use. The
 OS takes up 10K; there is the 4K block here that's unused, plus a few
 other unused areas in the ROM and, of course, there are the hardware
 chips. BASIC (or any cartridge) uses another 8K. The bottom 1792
 bytes are used by the OS, BASIC, and floating point package. Then
 DOS and DUP take up their memory space, not to mention the 850
 handler if booted -- leaving you with more or less 38K of RAM to use
 for your BASIC programming.

 ---------------------------------------------------------------------------
 Locations 53248 to 55295 ($D000 to $D7FF) are for ROM for the special
 I/O chips that Atari uses. The CTIA (or GTIA, depending on which
 you have) uses memory locations 53248 to 53503 ($D000 to $D0FF).
 POKEY uses 53760 to 54015 ($D200 to $D2FF). PIA uses 54016 to 54271
 ($D300 to $D3FF). ANTIC uses 54272 to 54783 ($D400 to $D5FF).
 ANTIC, POKEY and G/CTIA are Large Scale Integration (LSI) circuit
 chips. Don't confuse this chip ROM with the OS ROM which is be
 found in higher memory. For the most extensive description of these
 chips, see the Atari Hardware Manual.

 There are two blocks of unused, unavailable memory in the I/O areas:
 53504 to 53759 ($D100 to $D1FF) and 54784 to 55295 ($D600 to
 $D7FF).

 Many of the following registers can't be read directly, since they are
 hardware registers. Writing to them can often be difficult because in
 most cases the registers change every 30th second (stage two
 VBLANK) or even every 60th second (stage one VBLANK)! That's
 where the shadow registers mentioned earlier come in. The values
 written into these ROM locations are drawn from the shadow registers;
 to effect any "permanent" change in BASIC (i.e., while your program
 is running), you have to write to these shadow registers (in direct mode
 or while your program is running; these values will all be reset to their
 initialization state on RESET or powerup).

 Shadow register locations are enclosed in parentheses; see these
 locations for further descriptions. If no shadow register is mentioned,
 you may be able to write to the location directly in BASIC. Machine
 language is fast enough to write to the ROM locations and may be able
 to bypass the shadow registers entirely.

 Another feature of many of these registers is their dual nature. They
 are read for one value and written to for another. The differences
 between these functions are noted by the (R) for read and (W) for write
 functions. You will notice that many of these dual-purpose registers
 also have two labels.

 ---------------------------------------------------------------------------

 CTIA or GTIA

 53248-53505    D000-D0FF

      GTIA (or CTIA) is a special television interface chip designed
      exclusively for the Atari to process the video signal. ANTIC
      controls most of the C/GTIA chip functions. The GTIA shifts the
      display by one-half color clock off what the CTIA displays, so it
      may display a different color than the CTIA in the same piece of
      software. However, this shift allows players and playfields to
      overlap perfectly.

      There is no text window available in GTIA modes, but you can
      create a defined area on your screen with either a DLI (see
      COMPUTE!, September 1982) or by POKEing the GTIA mode
      number into location 87 ($57), POKEing 703 with four and then
      setting the proper bits in location 623 ($26F) for that mode. Only in
      the former method will you be able to get a readable screen,
      however. In the latter you will only create a four line, scrolling,
      unreadable window. You will be able to input and output as with
      any normal text window; you just won't be able to read it! GTIA,
      by the way, apparently stands for "George's Television Interface
      Adapter." Whoever George is, thanks, but what is CTIA?
      See the OS User's Manual, the Hardware Manual, De Re Atari and
      COMPUTE!, July 1982 to September 1982, for more information.


 53248           D000            HPOSP0

      (W) Horizontal position of player 0. Values from zero to 227 ($E3)
      are possible but, depending on the size of the playfield, the range
      can be from 48 ($30) as the leftmost position to 208 ($D0) as the
      rightmost position. Other positions will be "off screen."
      Here are the normal screen boundaries for players and missiles.
      The values may vary somewhat due to the nature of your TV
      screen. Players and missiles may be located outside these
      boundaries, but will not be visible (off screen):

                                Top
                            32 for single,
                         16 for double line
                             resolution
                   +--------------------------------+
                   |                                |
                   |                                |
                   |                                |
      48 for both  |                                | 208 for both
      resolutions  |                                | resolutions
                   |                                |
                   |                                |
                   |                                |
                   +--------------------------------+
                               Bottom
                           224 for single,
                         112 for double line
                              resolution

      Although you can POKE to these horizontal position registers, they
      are reset to zero immediately. The player or missile will stay on the
      screen at the location specified by the POKE, but in order to move
      it using the horizontal position registers, you can't use:

      POKE 53248, PEEK (53248) + n (or -n)

      which will end up generating an error message. Instead, you need
      to use something like this:

      10   POKE 704,220: GRAPHICS 1: HPOS =
          53248: POKE 623,8
      20   N = 100: POKE HPOS,N: POKE 53261
         ,255
      30   IF STICK(0) = 11 THEN N = N - 1:
          POKE HPOS,N: PRINT N
      40   IF STICK(0) = 7 THEN N = N + 1:
         POKE HPOS,N: PRINT N
      50   GOTO 30

      There are no vertical position registers for P/M graphics, so you
      must use software routines to move players vertically. One idea for
      vertical motion is to reposition the player within the P/M region
      rather than the screen RAM. For example, the program below uses
      a small machine language routine to accomplish this move:

      1 REM LINES 5 TO 70 SET UP THE PLAYER
      5 KEEP=PEEK(106)-16
      10 POKE 106,KEEP:POKE 54279,KEEP
      20 GRAPHICS 7+16:POKE 704,78:POKE 559
         ,46:POKE 53277,3
      30 PMBASE=KEEP*256
      40 FOR LOOP=PMBASE+512 TO PMBASE+640:
         POKE LOOP,0:NEXT LOOP:REM CLEAR OU
         T MEMORY FIRST
      50 X=100:Y=10:POKE 53248,X
      60 FOR LOOP=0 TO 7:READ BYTE:POKE PMB
         ASE+512+Y+LOOP,BYTE:NEXT LOOP:REM
         PLAYER GRAPHICS INTO MEMORY
      70 DATA 129,153,189,255,255,189,153,1
         29
      80 REM LINES 100 TO 170 SET UP MACHIN
         E LANGUAGE ROUTINE
      100 DIM UP$(21),DOWN$(21):UP=ADR(UP$)
          :DOWN=ADR(DOWN$)
      110 FOR LOOP=UP TO UP+20:READ BYTE:PO
          KE LOOP,BYTE:NEXT LOOP
      120 FOR LOOP=DOWN TO DOWN+20:READ BYT
          E:POKE LOOP,BYTE:NEXT LOOP
      130 DATA 104,104,133,204,104,133,203,
          160,1,177
      140 DATA 203,136,145,203,200,200,192,
          11,208,245,96
      150 DATA 104,104,133,204,104,133,203,
          160,10,177
      160 DATA 203,200,145,203,136,136,192,
          255,208,245,96
      200 REM VERTICAL CONTROL
      210 IF STICK(0)=14 THEN GOSUB 300
      220 IF STICK(0)=13 THEN D=USR(DOWN,PM
          BASE+511+Y):Y=Y+1
      250 GOTO 210
      300 U=USR(UP,PMBASE+511+Y):Y=Y-l
      310 RETURN
     
      DOWNLOAD MOVEPM.BAS

      This will move any nine-line (or less) size player vertically with the
      joystick. If you have a larger player size, increase the 11 in line 140
      to a number two larger than the number of vertical lines the player
      uses, and change the ten in line 150 to one greater than the
      number of lines. To add horizontal movement, add the following
      lines:

      6     HPOS = 53248
      230   IF STICK(0) = 11 THEN X = X - 1:
            POKE HPOS, X
      240   IF STICK(0) = 7 THEN X = X + 1:
           POKE HPOS, X

      You can use the routine to move any player by changing the
      number 511 in the USR calls to one less than the start address of the
      object to be moved. See the appendix for a map of P/M graphics
      memory use. Missiles are more difficult to move vertically with this
      routine, since it moves an entire byte, not bits. It would be useful
      for moving all four missiles vertically if you need to do so; they
      could still be moved horizontally in an individual manner.
      See COMPUTE!, December 1981, February 1982, and May 1982,
      for some solutions and some machine language move routines, and
      COMPUTE!, October 1981, for a solution with animation involving
      P/M graphics.


                               M0PF

      (R) Missile 0 to playfield collision. This register will tell you which
      playfield the object has "collided" with, i.e., overlapped. If missile
      0 collides with playfield two, the register would read four and so
      on. Bit use is:

            Bit     7    6    5    4    3    2    1    0
      Playfield     .....unused.....    3    2    1    0
      Decimal       ................    8    4    2    1


 53249          D00l           HOPSP1

      (W) Horizontal position of player 1.


                               M1PF

      (R) Missile 1 to playfield collision.


 53250           D002            HPOSP2

      (W) Horizontal position of player 2.


                               M2PF

      (R) Missile 2 to playfield collision.


 53251           D003            HPOSP3

      (W) Horizontal position of player 3.


                               M3PF

      (R) Missile 3 to playfield collision.


 53252           D004            HPOSM0

      (W) Horizontal position of missile 0. Missiles move horizontally like
      players. See the note in 53248 ($D000) concerning the use of
      horizontal registers.


                               P0PF

      (R) Player 0 to playfield collisions. There are some problems using
      collision detection in graphics modes nine to eleven. There are no
      obviously recognized collisions in GR.9 and GR.11. In GR.10
      collisions work only for the playfield colors that correspond to the
      usual playfield registers. Also, the background (BAK) color is set
      by PCOLR0 (location 704; $2C0) rather than the usual COLOR4
      (location 712; $2C8), which will affect the priority detection. In
      GR.10, playfield colors set by PCOLR0 to PCOLR3 (704 to 707;
      $2C0 to $2C3) behave like players where priority is concerned. Bit
      use is:

                 Bit     7    6    5    4    3    2    1    0
           Playfield     .....unused.....    3    2    1    0
           Decimal       ................    8    4    2    1


 53253           D005            HPOSM1

      (W) Horizontal position of missile 1.


                               P1PF

      (R) Player 1 to playfield collisions.


 53254           D006            HPOSM2

      (W) Horizonal position of missile 2.


                               P2PF

      (R) Player 2 to playfield collisions.


 53255           D007            HPOSM3

      (W) Horizontal position of missile 3.


                               P3PF

      (R) Player 3 to playfield collisions.


 53256           D008            SIZEP0

      (W) Size of player 0. POKE with zero or two for normal size (eight
      color clocks wide), POKE with one to double a player's width
      (sixteen color clocks wide), and POKE with three for quadruple
      width (32 color clocks wide). Each player can have its own width set.
      A normal size player might look something like this:

      00011000
      00111100
      01111110
      11111111
      11111111
      01111110
      00111100
      00011000

      In double width, the same player would like this:

      0000001111000000
      0000111111110000
      0011111111111100
      0011111111111100
      0000111111110000
      0000001111000000

      In quadruple width, the same player would become:

      00000000000011111111000000000000
      00000000111111111111111100000000
      00001111111111111111111111110000
      11111111111111111111111111111111
      11111111111111111111111111111111
      00001111111111111111111111110000
      00000000111111111111111100000000
      00000000000011111111000000000000

      Bit use is:

      Bit     7  6  5  4  3  2  1  0
      Size:   .....unused.....  0  0  Normal (8 color clocks)
                                0  1  Double (16 color clocks)
                                1  0  Normal
                                1  1  Quadruple (32 color clocks)


                               M0PL

      (R) Missile 0 to player collisions. There is no missile-to-missile
      collision register. Bit use is:

      Bit      7  6  5  4  3  2  1  0
      Player   ..unused..  3  2  1  0
      Decimal  ..........  8  4  2  1


 53257           D009            SIZEP1

      (W) Size of player 1.


                               M1PL

      (R) Missile 1 to player collisions.


 53258           D00A            SIZEP2

      (W) Size of player 2.


                               M2PL

      (R) Missile 2 to player collisions.


 53259           D00B            SIZEP3

      (W) Size of player 3.


                               M3PL

      (R) Missile 3 to player collisions.


 53260           D00C            SIZEM

      (W) Size for all missiles; set bits as below (decimal values
      included):

      Bits                  Size:
                            Normal   Double   Quadruple
         7 & 6: missile 3   0,128    64       192
         5 & 4: missile 2   0, 32    16        48
         3 & 2: missile l   0,  8     4        12
         1 & 0: missile 0   0,  2     1         3

      where turning on the bits in each each pair above does as follows:

         0 and 0: normal size -- two color clocks wide
         0 and 1: twice normal size -- four color clocks wide
         1 and 0: normal size
         1 and 1: four times normal size -- eight color clocks wide

      So, to get a double-sized missile 2, you would set BITs 5 and 6, or
      POKE 53260,48. Each missile can have a size set separately from
      the other missiles or players when using the GRAF registers.
      A number of sources, including De Re Atari, say that you can set
      neither missile sizes nor shapes separately. Here's a routine to
      show that you can in fact do both:

      10  POKE 53265,255: REM SHAPE START
      15  GR.7
      20  POKE 623,1: REM SET PRIORITIES
      30  FOR X = 1 TO 25
      35  F = 50
      40  FOR C = 704 TO 707: POKE C,F + X:
          F = F + 50: NEXT C: REM COLOURS
      45  S = 100
      50  FOR P = 53252 TO 53255: POKE P,S
         + X: S = S + 20: NEXT P : REM SCRE
         EN POSITIONS
      60  NEXT X
      70  INPUT A,B: REM MISSILE SIZE AND S
         HAPES
      80  POKE 53260,A: POKE 53265,5
      100 GOTO 30

      Here's another example using DMA; GRACTL and DACTL
      (53277 and 54272; $D0lD and $D400):

      10  POKE 623,1: POKE 559,54: POKE 542
         79, 224: POKE 53277,1
      20  FOR N = 53252 TO 53255: POKE N, 1
         00 + X: X = X + 10: NEXT N: X = 0
      30  INPUT SIZE: POKE 53260, SIZE
      40  GOTO 30

      See 54279 ($D407) for more information on P/M graphics.


                               P0PL

      (R) Player 0 to player collisions. Bit use is:

      Bit       7   6   5   4   3   2   1   0
      Player    ...unused....   3   2   1   0
      Decimal   .............   8   4   2   1


 53261           D00D            GRAFP0

      (W) Graphics shape for player 0 written directly to the player
      graphics register. In using these registers, you bypass ANTIC.
      You only use the GRAFP# registers when you are not using
      Direct Memory Access (DMA: see GRACTL at 53277). If DMA is
      enabled, then the graphics registers will be loaded automatically
      from the area specified by PMBASE (54279; $D407).

      The GRAF registers can only write a single byte to the playfield,
      but it runs the entire height of the screen. Try this to see:

      10  POKE 53248, 160: REM SET HORIZONT
         AL POSITION OF PLAYER 0
      20  POKE 704, 245: REM SET PLAYER 0 C
         OLOUR TO ORANGE
      30  POKE 53261, 203: REM BIT PATTERN
         11001011

      To remove it, POKE 53261 with zero. The bit order runs from
      seven to zero, left to right across the TV screen. Each bit set will
      appear as a vertical line on the screen. A value of 255 means all
      bits are set, creating a wide vertical line. You can also use the
      size registers to change the player width. Using the GRAF
      registers will allow you to use players and missiles for such things
      as boundaries on game or text fields quite easily.


                               P1PL

      (R) Player 1 to player collisions.


 53262           D00E            GRAFP1

      (W) Graphics for player 1.


                               P2PL

      (R) Player 2 to player collisions.


 53263           D00F            GRAFP2

      (W) Graphics for player 3.


                               P3PL

      (R) Player 3 to player collisions.


 53264           D010            GRAFP3

      (W) Graphics for player 3.


                               TRIG0

      (R) Joystick trigger 0 (644). Controller jack one, pin six. For all
      triggers, zero equals button pressed, one equals not pressed. If
      BIT 2 of GRACTL (53277; $D01D) is set to one, then all TRIG
      BITs 0 are latched when the button is pressed (set to zero) and are
      only reset to one (not pressed) when BIT 2 of GRACTL is reset to
      zero. The effect of latching the triggers is to return a constant
      "button pressed" read until reset.


 53265           D011            GRAFM

      (W) Graphics for all missiles, not used with DMA. GRAFM works
      the same as GRAFP0 above. Each pair of bits represents one
      missile, with the same allocation as in 53260 ($D00C) above.

          Bit  7 6  5 4  3 2  1 0
      Missile  -3-  -2-  -1-  -0-

      Each bit set will create a vertical line running the entire height of
      the TV screen. Missile graphics shapes may be set separately
      from each other by using the appropriate bit pairs. To mask out
      unwanted players, write zeros to the bits as above.


                               TRIG1

      (R) Joystick trigger 1 (645). Controller jack two, pin six.


 53266           D012            COLPM0

      (W) Color and luminance of player and missile 0 (704). Missiles
      share the same colors as their associated players except when
      joined together to make a fifth player. Then they take on the same
      value as in location 53733 ($D019; color register 3).


                               TRIG2

      (R) Joystick trigger 2 (646). Controller jack three, pin six.


 53267           D013            COLPM1

      (W) Color and luminance of player and missile 1 (705).


                               TRIG3

      (R) Joystick trigger 3 (647). Controller jack four, pin six.


 53268           D014            COLPM2

      (W) Color and luminance of player and missile 2 (706).


                               PAL

      (R) Used to determine if the Atari is PAL (European and Israeli
      TV compatible when BITs 1 - 3 equal zero) or NTSC (North
      American compatible when BITs 1 - 3 equal one; 14 decimal, $E).
      European Ataris run 12% slower if tied to the VBLANK cycle (the
      PAL VBLANK cycle is every 50th second rather than every 60th
      second). They use only one CPU clock at three MHZ, so the 6502
      runs at 2.217 MHZ -- 25% faster than North American Ataris.
      Also, their $E000 and $F000 ROMs are different, so there are
      possible incompatibilities with North American Ataris in the
      cassette handling routines. There is a third TV standard called
      SECAM, used in France, the USSR, and parts of Africa. I am
      unaware if there is any Atari support for SECAM standards.

      PAL TV has more scan lines per frame, 312 compared to 262.
      NTSC Ataris compensate by adding extra lines at the beginning
      of the VBLANK routine. Display lists do not have to be altered,
      and colors are the same because of a hardware modification.


 53269           D015            COLPM3

      Color and luminance of player and missile 3 (707).


 53270           D016            COLPF0

      Color and luminance of playfield zero (708).


 53271           D017            COLPF1

      Color and luminance of playfield one (709).


 53272           D018            COLPF2

      Color and luminance of playfield two (710).


 53273           D019            COLPF3

      Color and luminance of playfield three (711).


 53274           D01A            COLBK

      Color and luminance of the background (BAK).(712).


 53275           D01B            PRIOR

      (W) Priority selection register. PRIOR establishes which objects
      on the screen (players, missiles, and playfields) will be in front of
      other objects. Values used in this register are also described at
      location 623 ($26F), the shadow register. If you use conflicting
      priorities, objects whose priorities are in conflict will turn black
      in their overlap region.

      Priority order
       (Decimal values in brackets):

      Bit 0 = 1 (1):            Bit 1 = 1 (2):
      Player 0                  Player 0
      Player 1                  Player 1
      Player 2                  Playfield 0
      Player 3                  Playfield 1
      Playfield 0               Playfield 2
      Playfield 1               Playfield 3 and Player 5
      Playfield 2               Player 2
      Playfield 3 and Player 5  Player 3
      Background                Background

      Bit 2 = 1 (4):            Bit 3 = 1 (8):
      Playfield 0               Playfield 0
      Playfield 1               Playfield 1
      Playfield 2               Player 0
      Playfield 3 and Player 5  Player 1
      Player 0                  Player 2
      Player 1                  Player 3
      Player 2                  Playfield 2
      Player 3                  Playfield 3 and Player 5
      Background                Background

      Bit 4 = 1: Enable a fifth player out of the four missiles.

      Bit 5 = 1: Overlap of players 0 and 1, 2 and 3 is third color (else
      overlap is black). The resulting color is a logical OR of the two
      player colors.

      Bits 6 and 7 are used to select GTIA modes:
           0     0 = no GTIA modes
           0     1 = GTIA GR.9
           1     0 = GTIA GR.10
           1     1 = GTIA GR.11


 53276           D01C            VDELAY

      (W) Vertical delay register. Used to give one-line resolution
      movement capability in the vertical positioning of an object when
      the two line resolution display is enabled. Setting a bit in
      VDELAY to one moves the corresponding object down by one TV
      line. If DMA is enabled, then moving an object by more than one
      line is accomplished by moving bits in the memory map instead.

      Bit   Decimal   Object
      7       128     Player 3
      6        64     Player 2
      5        32     Player 1
      4        16     Player 0
      3         8     Missile 3
      2         4     Missile 2
      1         2     Missile 1
      0         1     Missile 0


 53277           D01D            GRACTL

      (W) Used with DMACTL (location 54272; $D400) to latch all stick
      and paddle triggers (to remember if triggers on joysticks or
      paddles have been pressed), to turn on players and to turn on
      missiles. To get the values to be POKEd here, add the following
      options together for the desired function:

                              Decimal   Bit
      To turn on missiles        1       0
      To turn on players         2       1
      To latch trigger inputs    4       2

      To revoke P/M authorization and turn off both players and
      missiles, POKE 53277,0. Once latched, triggers will give a
      continuous "button pressed" read the first time they are pressed
      until BIT 2 is restored to zero. Triggers are placed in "latched"
      mode when each individual trigger is pressed, but you cannot set
      the latch mode for individual triggers.

      Have you ever hit BREAK during a program and still had players
      or their residue left on the screen? Sometimes hitting RESET
      doesn't clear this material from the screen. There are ways to get
      rid of it:

      POKE 623,4: This moves all players behind playfields.
      POKE 53277,0: This should turn them off.
      POKE 559,2: This should return you to a blank screen.

      Make sure you SAVE your program before POKEing, just in
      case!


 53278           D01E            HITCLR

      (W) POKE with any number to clear all player/missile collision
      registers. It is important to clear this register often in a program
      -- such as a game -- which frequently tests for collisions.
      Otherwise, old collision values may remain and confuse the
      program. A good way to do this is to POKE HITCLR just before
      an event which may lead to a collision; for example, right before
      a joystick or paddle is "read" to move a player or fire a missile.
      Then test for a collision immediately after the action has taken
      place. Remember that multiple collisions cause sums of the
      collision values to be written to the collision registers; if you do
      not clear HITCLR often enough, a program checking for
      individual collisions will be thrown off by these sums.


 53279           D01F            CONSOL

      (W/R) Used to see if one of the three yellow console buttons has
      been pressed (not the RESET button!). To clear the register,
      POKE CONSOL with eight. POKEing any number from zero to
      eight will cause a click from the speaker. A FOR-NEXT loop that
      alternately POKEs CONSOL with eight and zero or just zero,
      since the OS put in an 8 every 1/60 second, will produce a buzz.
      Values PEEKed will range from zero to seven according to the
      following table:

      |Key        Value    0    1    2    3    4    5    6    7    |
      |                                                            |
      +------------------------------------------------------------+
      |                                                            |
      |OPTION              X    X    X    X                        |
      |SELECT              X    X              X    X              |
      |START               X         X         X         X         |
      |                                                            |
      +------------------------------------------------------------+
       Bits   2            0    0    0    0    1    1    1    1
              1            0    0    1    1    0    0    1    1
              0            0    1    0    1    0    1    0    1


      Where zero means all keys have been pressed, one means
      OPTION and SELECT have been pressed, etc., to seven, which
      means no keys have been pressed. CONSOL is updated every
      stage two VBLANK procedure with the value eight.

      It is possible to use the console speaker to generate different
      sounds. Here is one idea based on an article in COMPUTE!,
      August 1981:

      10   GOSUB 1000
      20   TEST = USR(1536)
      999  END
      1000 FOR LOOP = 0 TO 26: READ BYTE: P
           OKE 1536 + LOOP, BYTE: NEXT LOOP
           : RETURN
      1010 DATA 104,162,255,169,255,141,31,
           208,169
      1020 DATA 0,160,240,136,208,253,141,3
           1,208,160
      1030 DATA 240,136,208,253,202,208,233
           ,96

      To change the tone, you POKE 1547 and 1555 with a higher or
      lower value (both are set to 240 above). To change the tone
      duration, you POKE 1538 with a lower value (it is set to 255 in the
      routine above). Do these before you do your USR call or alter the
      DATA statements to permanently change the values in your own
      program. Turn off DMA (see location 559) to get clearer tones.

 ---------------------------------------------------------------------------
 Locations 53280 to 53503 ($D020 to $D0FF) are repeats of locations
 53248 to 53279 ($D000 to $D01F). You can't use any of the repeated
 locations; consider them "filler." They maybe used for other purposes
 in any Atari OS upgrade.

 ---------------------------------------------------------------------------
 Locations 53504 to 53759 ($D100 to $D1FF) are unused. These loca-
 tions are not empty; you can PEEK into them and find out what's
 there. They cannot, however, be user-altered.

 ---------------------------------------------------------------------------


 POKEY

 53760-54015    D200-D2FF

      POKEY is a digital I/O chip that controls the audio frequency and
      control registers, frequency dividers, poly noise counters, pot
      (paddle) controllers, the random number generator, keyboard
      scan, serial port I/O, and the IRQ interrupts.

      The AUDF# (audio frequency) locations are used for the pitch for
      the corresponding sound channels, while the AUDC# (audio
      control registers) are the volume and distortion values for those
      same channels. To POKE sound values, you must first POKE zero
      into locations 53768 ($D208) and a three into 53775 ($D20F).

      Frequency values can range from zero to 255 ($FF), although the
      value is increased by the computer by one to range from one to
      256. Note that the sum of the volumes should not exceed 32, since
      volume is controlled by the least four bits. It is set from zero as no
      volume to 15 ($F) as the highest. A POKE with 16 ($10) forces
      sound output even if volume is not set (i.e., it pushes the speaker
      cone out. A tiny "pop" will be heard). The upper four bits control
      distortion: 192 ($C0) is for pure tone; other values range from 32 to
      192. Note that in BASIC, the BREAK key will not turn off the
      sound; RESET will, however. See De Re Atari and BYTE, April
      1982, for more information on sound generation.

      The AUDF registers are also used as the POKEY hardware timers.
      These are generally used when counting an interval less than one
      VBLANK. For longer intervals, use the software timers in locations
      536 to 545 ($218 to $221). You load the AUDCTL register with the
      number for the desired clock frequency. You then set the volume
      to zero in the AUDC register associated with the AUDF register
      you plan to use as a timer. You load the AUDF register itself with
      the number of clock intervals you wish to count. Then you load
      your interrupt routine into memory, and POKE the address into the
      appropriate timer vector between locations 528 and 533 ($210 and
      $215). You must set the proper bit(s) in IRQEN and its shadow
      register POKMSK at location 16 ($10) to enable the interrupt.
      Finally, you load STIMER with any value to load and start the
      timer(s). The OS will force a jump to the timer vector and then to
      your routine when the AUDF register counts down to zero. Timer
      processing can be preempted by ANTIC's DMA, a DLI, or the
      VBLANK process.

      POT values are for the paddles, ranging from zero to 240,
      increasing as the paddle knob is turned counterclockwise, but
      values less than 40 and greater than 200 represent an area on
      either edge of the screen that may not be visible on all TV sets or
      monitors.


 53760           D200            AUDF1

      (W) Audio channel one frequency. This is actually a number (N)
      used in a "divide by N circuit"; for every N pulses coming in (as set
      by the POKEY clock), one pulse goes out. As N gets larger, output
      pulses will decrease, and thus the sound produced will be a lower
      note. N can be in the range from one to 256; POKEY adds one to
      the value in the AUDF register. See BYTE, April 1982, for a
      program to create chords instead of single tones.


                               POT0

      (R) Pot (paddle) 0 (624); pot is short for potentiometer. Turning the
      paddle knob clockwise results in decreasing pot values. For
      machine language use: these pot values are valid only 228 scan
      lines after the POTGO command or after ALLPOT changes (see
      53768; $D208 and 53771; $D20B). POT registers continually count
      down to zero, decrementing every scan line. They are reset to 228
      when they reach zero or by the values read from the shadow
      registers. This makes them useful as system timers. See
      COMPUTE!, February 1982, for an example of this use.

      The POTGO sequence (see 53771; $D20B) resets the POT
      registers to zero, then reads them 228 scan lines later. For the fast
      pot scan, BIT 2 of SKCTL at 53775 ($D20F) must be set.


 53761           D201            AUDC1

      (W) Audio channel one control. Each AUDF register has an
      associated control register which sets volume and distortion levels.
      The bit assignment is:

      Bit   7   6   5      4     3   2   1   0
           Distortion   Volume      Volume
             (noise)     only        level
            0   0   0      0     0   0   0   0   Lowest
            0   0   1            0   0   0   1
             etc. to:             etc. to:
            1   1   1      1     1   1   1   1   Highest
                        (forced
                        output)

      The values for the distortion bits are as follows. The first process is
      to divide the clock value by the frequency, then mask the output
      using the polys in the order below. Finally, the result is divided by
      two.

      Bit
      7    6    5
      0    0    0  five bit, then 17 bit, polys
      0    0    1  five bit poly only
      0    1    0  five bit, then four bit, polys
      0    1    1  five bit poly only
      1    0    0  l7 bit poly only
      1    0    1  no poly counters (pure tone)
      1    1    0  four bit poly only
      1    1    1  no poly counters (pure tone)

      In general, the tones become more regular (a recognizable
      droning becomes apparent) with fewer and lower value polys
      masking the output. This is all the more obvious at low frequency
      ranges. POKE with 160 ($A0) or 224 ($E0) plus the volume for pure
      tones.

      See De Re Atari and the Hardware Manual for details.


                               POT1

      (R) Pot 1 register (625).


 53762           D202            AUDF2

      (W) Audio channel two frequency. Also used with AUDF3 to store
      the 19200 baud rate for SIO.


                               POT2

      (R) Pot 2 (626).


 53763           D203            AUDC2

      (W) Audio channel two control.


                               POT3

      (R) Pot 3 (627).


 53764           D204            AUDF3

      (W) Audio channel three frequency. Used with AUDF3 above and
      with AUDF4 to store the 600 baud rate for SIO.


                               POT4

      (R) Pot 4 (628).


 53765           D205            AUDC3

      (W) Audio channel three control.


                               POT5

      (R) Pot 5 (629).


 53766           D206            AUDF4

      (W) Audio channel four frequency.


                               POT6

      (R) Pot 6 (630).


 53767           D207            AUDC4

      (W) Audio channel four control.


                               POT7

      (R) Pot 7 (631).


 53768           D208            AUDCTL

      (W) Audio control. To properly initialize the POKEY sound
      capabilities, POKE AUDCTL with zero and POKE 53775,3
      ($D20F). These two are the equivalent of the BASIC statement
      SOUND 0,0,0,0. AUDCTL is the option byte which affects all
      sound channels. This bit assignment is:

      Bit    Description:
      7      Makes the 17 bit poly counter into nine bit poly
             (see below)
      6      Clock channel one with 1.79 MHz
      5      Clock channel three with 1.79 MHz
      4      Join channels two and one (16 bit)
      3      Join channels four and three (16 bit)
      2      Insert high pass filter into channel one, clocked by channel
             two
      1      Insert high pass filter into channel two, clocked by channel
             four
      0      Switch main clock base from 64 KHz to 15 KHz

      Poly (polynomial) counters are used as a source of random pulses
      for noise generation. There are three polys: four, five and 17 bits
      long. The shorter polys create repeatable sound patterns, while the
      longer poly has no apparent repetition. Therefore, setting BIT 7
      above, making the 17-bit into a nine-bit poly will make the pattern
      in the distortion more evident. You chose which poly(s) to use by
      setting the high three bits in the AUDC registers. The 17-bit poly is
      also used in the generation of random numbers; see 53770
      ($D20A).

      The clock bits allow the user to speed up or slow down the clock
      timers, respectively, making higher or lower frequency ranges
      possible. Setting the channels to the 1.79 MHz will produce a
      much higher sound, the 64 KHz clock will be lower, and the 15
      KHz clock the lowest. The clock is also used when setting the
      frequency for the AUDF timers.

      Two bits (three and four) allow the user to combine channels one
      and two or three and four for what amounts to a nine octave range
      instead of the usual five. Here's an example from De Re Atari of
      this increased range, which uses two paddles to change the
      frequency: the right paddle makes coarse adjustments, the left
      paddle makes fine adjustments:

      10 SOUND 0,0,0,0:POKE 53768,80:REM SE
         T CLOCK AND JOIN CHANNELS 1 AND 2
      20 POKE 53761,160:POKE 53763,168:REM
         TURN OFF CHANNEL 1 AND SET 2 TO PU
         RE TONE GENERATION
      50 POKE 53760,PADDLE(0):POKE 53762,PA
         DDLE(1):GOTO 30

      High pass filters allow only frequencies higher than the clock value
      to pass through. These are mostly used for special effects. Try:

      10 SOUND 0,0,0,0:POKE 53768,4:REM HIG
         H PASS FILTER ON CHANNEL 1
      20 POKE 53761,168:POKE 53765,168:REM
         PURE TONES
      30 POKE 53760,254:POKE 53764,127
      40 GOTO 40

      See the excellent chapter on sound in De Re Atari: it is the best
      explanation of sound functions in the Atari available. See also the
      Hardware Manual for complete details.


                               ALLPOT

      (R) Eight line pot port state; reads all of the eight POTs together.
      Each bit represents a pot (paddle) of the same number. If a bit is
      set to zero, then the register value for that pot is valid (it's in use); if
      it is one, then the value is not valid. ALLPOT is used with the
      POTGO command at 53771 ($D20B).

      ----------------------------------------------------------------------

 53769           D209            STIMER

      (W) Start the POKEY timers (the AUDF registers above). You
      POKE any non-zero value here to load and start the timers; the
      value isn't itself used in the calculations. This resets all of the audio
      frequency dividers to their AUDF values. If enabled by IRQEN
      below, these AUDF registers generate timer interrupts when they
      count down from the number you POKEd there to zero. The
      vectors for the AUDF1, AUDF2 and AUDF4 timer interrupts are
      located between 528 and 533 ($210 and $215). POKEY timer four
      interrupt is only enabled in the new "B" OS ROMs.


                               KBCODE

      (R) Holds the keyboard code which is then loaded into the shadow
      register (764; $2FC) when a key is hit. Usually read in response to
      the keyboard interrupt. Compares the value with that in CH1 at
      754 ($2F2). If both values are the same, then the new code is
      accepted only if a suitable key debounce delay time has passed.
      The routines which test to see if the key code will be accepted start
      at 65470 ($FFBE). BIT 7 is the control key flag, BIT 6 is the shift key
      flag.


 53770           D20A            SKREST

      (W) Reset BITs 5 - 7 of the serial port status register at 53775 to one.


                               RANDOM

      (R) When this location is read, it acts as a random number
      generator. It reads the high order eight bits of the 17 bit
      polynomial counter (nine bit if BIT 7 of AUDCTL is set) for the
      value of the number. You can use this location in a program to
      generate a random integer between zero and 255 by:

      10  PRINT PEEK(53770)

      This is a more elegant solution than INT(RND(0) * 256). For a test of
      the values in this register, use this simple program:

      10 FOR N = 1 TO 20: PRINT PEEK(53770): NEXT N


 53771           D20B            POTGO

      (W) Start the POT scan sequence. You must read your POT values
      first and then start the scan sequence, since POTGO resets the
      POT registers to zero. Written by the stage two VBLANK
      sequence.


 53772           D20C            ....

      Unused.


 53773           D20D            SEROUT

      (W) Serial port data output. Usually written to in the event of a
      serial data out interrupt. Writes to the eight bit (one byte) parallel
      holding register that is transferred to the serial shift register when a
      full byte of data has been transmitted. This "holding" register is
      used to contain the bits to be transmitted one at a time (serially) as
      a one-byte unit before transmission.


                               SERIN

      (R) Serial port input. Reads the one-byte parallel holding register
      that is loaded when a full byte of serial input data has been
      received. As above, this holding register is used to hold the bits as
      they are received one bit at a time until a full byte is received. This
      byte is then taken by the computer for processing. Also used to
      verify the checksum value at location 49 ($31).

      The serial bus is the port on the Atari into which you plug your
      cassette or disk cable. For the pin values of this port, see the OS
      User's Manual, p. 133, and the Hardware Manual.


 53774           D20E            IRQEN

      (W) Interrupt request enable. Zero turns off all interrupt requests
      such as the BREAK key; to disable or re-enable interrupts, POKE
      with the values according to the following chart (setting a bit to one
      -- i.e., true -- enables that interrupt; decimal values are also
      shown for each bit):

      Bit Decimal     Interrupt                         Vector
      0       1       Timer 1 (counted down to zero)    VTIMR1
                                                        (528; $210)
      1       2       Timer 2 (counted down to zero)    VTIMR2
                                                        (530; $212)
      2       4       Timer 4 (counted down to zero)    VTIMR4
                                                        (532; $214), OS
                                                        "B" ROMs only)
      3       8       Serial output transmission done   VSEROC (526;
                                                        $20E)
      4      16       Serial output data needed         VSEROR
                                                        (524; $20C)
      5      32       Serial input data ready           VSERIN
                                                        (522; $20A)
      6      64       Other key pressed                 VKEYBD
                                                        (520; $208)
      7     128       BREAK key pressed                 see below

      Here is the procedure for the BREAK key interrupt: clear the
      interrupt register. Set BRKKEY (17; $11) to zero; clear the
      start/stop flag SSFLAG at 767 ($2FF); clear the cursor inhibit flag
      CRSINH at 752 ($2F0); clear the attract mode flag at 77 ($4D), and
      return from the interrupt after restoring the 6502 A register. (There
      is now (in the OS "B" ROMs) a proper vector for BREAK key
      interrupts at 566, 567 ($236, $237) which is initialized to point to
      59220 ($E754).) If the interrupt was due to a serial I/O bus proceed
      line interrupt, then vector through VPRCED at 514 ($202). If due to
      a serial I/O bus interrupt line interrupt, then vector through
      VINTER at 516 ($204). If due to a 6502 BRK instruction, then vector
      through VBREAK at 518 ($206).

      Timers relate to audio dividers of the same number (an interrupt is
      processed when the dividers count down to zero). These bits in
      IRQEN are not set on powerup and must be initiated by the user
      program before enabling the processor IRQ.
      There      are two other interrupts, processed by PIA, generated over
      the serial bus Proceed and Interrupt lines, set by the bits in the
      PACTL and PBCTL registers (54018 and 54019; $D302, $D303):

      Bit Decimal Locution Interrupt
      0       1   PACTL    Peripheral A (PORTA) interrupt enable
                           bit.
      7     128   PACTL    Peripheral A interrupt status bit.
      0       1   PBCTL    Peripheral B (PORTB) interrupt enable
                           bit.
      7     128   PBCTL    Peripheral B interrupt status bit.

      The latter PORT interrupts are automatically disabled on powerup.
      Only the BREAK key and data key interrupts are enabled on
      powerup. The shadow register is 16 ($10).


                               IRQST

      (R) Interrupt request status. Bit functions are the same as IRQEN
      except that they register the interrupt request when it is zero rather
      than the enable when a bit equals one. IRQST is used to determine
      the cause of interrupt request with IRQEN, PACTL and PBCTL as
      above.

      All IRQ interrupts are normally vectored through 65534 ($FFFE) to
      the IRQ service routine at 59123 ($E6F3), which determines the
      cause of the interrupt. The IRQ global RAM vector VIMIRQ at 534
      ($216) ordinarily points to the IRQ processor at 59126 ($E6F6). The
      processor then examines 53774 ($D20E) and the PIA registers at
      54018 and 54019 to determine the interrupt cause. Once
      determined, the routine vectors through one of the IRQ RAM
      vectors in locations 514 to 526 ($202 to $20E). For Non-Maskable
      Interrupts (NMI's), see locations 54286 to 54287 ($D40E; $D40F).
      See the OS User's Manual for complete details.


 53775           D20F            SKCTL

      (W) Serial port control. Holds the value 255 ($255) if no key is
      pressed, 251 ($FB) for most other keys pressed, 247 ($F7) for
      SHIFT key pressed (*M). See the (R) mode below for an
      explanation of the bit functions. POKE with three to stop the
      occasional noise from cassette after I/O to bring POKEY out of the
      two-tone mode. (562).


                               SKSTAT

      (R) Beads the serial port status. It also returns values governed by
      a signal on the digital track of the cassette tape. You can generate
      certain values using the SOUND command in BASIC and a PEEK
      to SKSTAT:

      SOUND 0,5,10,15 returns a value to here of 255 (or, on
        occasion, 127).
      SOUND 0,8,10,3 returns a value of 239.

      This is handy for adding a voice track to Atari tapes. You use the
      left channel for your voice track and the right for the tone(s) you
      want to use as cuing marks. You can use the speaker on your TV to
      generate the tones by placing the right microphone directly in
      front of the speaker. The computer will register these tones in this
      register when it encounters them during a later cassette load. See
      COMPUTE!, July 1981, for some other suggestions on doing this.
      Bemember, you can turn the cassette off by POKEing 54018
      ($D302) with 60 ($3C) and back on with 52 ($34).

      Bits in the SKCTL (W) register are normally zero and perform the
      functions below when set to one. The status when used as (R) is
      listed below the write (W) function:

      Bit   Function
      0     (W) Enable keyboard debounce circuits.
            (R) Not used by SKSTAT.
      1     (W) Enable keyboard scanning circuit.
            (R) Serial input shift register busy.
      2     (W) Fast pot scan: the pot scan counter completes its
            sequence in two TV line times instead of one frame time (228
            scan lines). Not as accurate as the normal pot scan,
            however.
            (R) the last key is still pressed.
      3     (W) Serial output is transmitted as a two-tone signal rather
            than a logic true/false. POKEY two-tone mode.
            (R) The shift key is pressed.
      4,5,6 (W) Serial port mode control used to set the bi-directional
            clock lines so that you can either receive external clock data
            or provide clock data to external devices (see the Hardware
            Manual, p. II.27). There are two pins on the serial port for
            Clock IN and Clock OUT data. See the OS User's Manual,
            p. 133.
      4     (R) Data can be read directly from the serial input port,
            ignoring the shift register.
      5     (R) Keyboard over-run. Reset BITs 7 to 5 (latches) to one
            using SKRES at 53770 ($D20A).
      6     (R) Serial data input over-run. Reset latches as above.
      7     (W) Force break (serial output to zero).
           (R) Serial data input frame error caused by missing or extra
           bits. Beset latches as above.

      BIT 2 is first set to zero to reset POT registers to zero (dumping the
      capacitors used to change the POT registers). Then BIT 2 is set to
      one to enable the fast scan. Fast scan is not as accurate as the
      normal scan routine. BIT 2 must be reset to zero to enable the
      normal scan mode; otherwise, the capacitors will never dump.

 ---------------------------------------------------------------------------
 Locations 53776 to 54015 ($D210 to $D2FF) are duplications of locations
 53760 to 53775 and have no particular use at present.

 ---------------------------------------------------------------------------


 PIA: 6520 CHIP

 54016-54271    D300-D3FF

      The Peripheral Interface Adapter (PIA) integrated circuit is a
      special microprocessor used to control the Atari ports, controller
      jacks one to four. Ports can be used for both input and output
      simultaneously or alternately. Barely tapped at the time of this
      writing, the ports represent a major resource for external (and
      internal) control and expansion. PIA also processes two of the IRQ
      interrupts: VINTER and VPRCED, vectored at locations 514 to 517
      ($202 to $205). These interrupts are unused by the OS, but also
      may be used to provide greater control over external devices.


 54016           D300            PORTA

      (W/R) Reads or writes data from controller jacks one and two if BIT
      2 of PACTL (location 54018) is one. Writes to direction control if
      BIT 2 of PACTL is zero.

      These two port registers also control the direction of data flow to
      the port, if the controller register (54018, below) is POKEd with 48
      ($30). Then, if the bits in the register read zero, it is in input (R)
      mode; if they read one, it is in output (W) mode. A zero POKEd
      here makes all bits input, a 255 ($FF) makes all bits output. BITs 0
      to 3 address pins one to four on jack one, BITs 4 to 7 address pins
      one to four on jack two. POKE 54018 with 52 to make this location
      into a data register again. Shadow registers are: STICK0 (632;
      $278, jack one), STICK1 (633; $279, jack two) and PTRIG0-3
      (636-639; $27C-$27F).

      Bits used as data register
      7    6    5    4    3    2    1    0
         --Jack 0--        --Jack 1--
         --Stick 1--       --Stick 0--

      Forward  = BIT 0, 4 = 1
      Backward = BIT 1, 5 = 1
      Left     = BIT 2,6 = 1
      Right    = BIT 3,7 = 1
      Neutral  = All four jack bits = 1

      PORTA is also used to test if the paddle 0-3 triggers (PTRIG) have
      been pressed, using these bits:

      Bit       7     6     5     4     3     2     1     0
      PTRIG     3     2     -     -     1     0     -     -

      Where zero in the appropriate bit equals trigger pressed, one
      equals trigger not pressed.

      The PORT registers are also used in the keyboard controller (used
      with a keypad) operation where:

      Bit       7     6     5     4     3     2     1     0
      Row       4     3     2    Top    4     3     2    Top
      Jack     ..........2..........   ..........1...........

      Columns for the keyboard operation are read through the POT
      (PADDL) and TRIG registers. See Micro, May 1982, and the
      Hardware Manual for more information on jacks and ports.


 54017           D301            PORTB

      (W/R) Port B. Reads or writes data to and/or from jacks three and
      four. Same as PORTA, above, for the respective jacks. Shadow
      registers are: STICK2 (634; $27A, jack three), STICK3 (635, $27B,
      jack four), and PTRIG4-7 (640-643; $280-$283).


 54018           D302            PACTL

      (W/R) Port A controller (see 54016 above). POKE with 60 ($3C) to
      turn the cassette motor off, POKE with 52 to turn it on. You can put
      a music cassette in your program recorder, press PLAY and then
      POKE 54018,52. Your music will play through the TV speaker or
      external amplifier while you work at the Atari. You can use this
      technique to add voice tracks to your programs. To turn off the
      music or voice, type POKE 54018,60.

      PACTL can be used for other external applications by the user. Bit
      use is as follows:

      Bit             Function
      7 (read only)   Peripheral A interrupt (IRQ) status bit. Set by
                      Peripheral (PORT) A. Reset by reading PORTA
                      (53774; $D20E).
      6               Set to zero.
      5               Set to one.
      4               Set to one.
      3 (write)       Peripheral motor control line (turn the cassette on
                      or off; zero equals on).
      2 (write)       Controls PORTA addressing. One equals PORTA
                      register; zero equals direction control register.
      1               Set to zero.
      0 (write)       Peripheral A interrupt (IRQ) enable. One equals
                      enable. Set by the OS but available to the user;
                      reset on powerup.


 54019           D303            PBCTL

      (W/R) Port B controller. Initialized to 60 ($3C) by the OS IRQ
      code. PBCTL is the same as PACTL, above, with the following
      exception (this may actually perform the same function as in
      PACTL, but I am not sure of the distinction between descriptions):

      Bit             Function
      3               Peripheral command identification (serial bus
                      command), initialized to 60 ($3C).

      Ports can be used for external control applications by the
      technically minded reader who is willing to do some soldering to
      develop cables and connectors. A good example can be found in
      COMPUTE!, February 1981, where the author gives directions for
      using jacks three and four as a printer port. The Macrotronic
      printer cables use just this method, bypassing the 830 interface
      entirely (one way of reducing your hardware costs). Theoretically,
      the entire Atari can be controlled through the ports!

 ---------------------------------------------------------------------------
 Locations 54020 to 54271 ($D304 to $D3FF) are repeats of locations
 54016 to 54019 ($D300 to $D303).

 ---------------------------------------------------------------------------


 ANTIC

 54272-54783    D400-D5FF

      ANTIC is a special, separate microprocessor used in your Atari
      to control C/GTIA, the screen display, and other screen-related
      functions including processing the NMI interrupts. It uses its own
      instruction set, called the display list, which tells ANTIC where to
      find the screen data in RAM and how to display it. ANTIC also
      uses an internal four bit counter called the Delta Counter (DCTR)
      to control the vertical dimension of each block.


 54272           D400            DMACTL

      (W) Direct Memory Access (DMA) control. It is also used to
      define one- or two-line resolution for players and to turn on
      players and missiles. Values are POKEd into the shadow register,
      559 ($22F), and are also described there. You POKE the shadow
      register with the following numbers in order to:

      Turn off the playfield                           0
      Use narrow playfield                             1
      Use normal playfield                             2
      Use wide playfield                               3
      Enable missile DMA                               4
      Enable player DMA                                8
      Enable both player and missile DMA              12
      Single line player resolution                   16
      Enable DMA Fetch instructions                   32

      Double line resolution is the default status. Use this register in
      conjunction with GRACTL at 53277 ($D01D). Both must be set
      properly or no display will result. BIT 5 enables DMA to fetch the
      display list instructions. If BIT 5 is not set (BIT 5 equals zero),
      ANTIC will not work. DMACTL is initialized to 34 ($22).
      A player in single line resolution might look like this:

      00011000                ##
      00111100               ####
      01111110              ######
      11111111             ########
      11111111             ########
      01111110              ######
      00111100               ####
      00011000                ##

      so that each byte is displayed on one TV line. The same player in
      double line resolution would look like this:

      00011000                ##
      00011000                ##
      00111100               ####
      00111100               ####
      01111110              ######
      01111110              ######
      11111111             ########
      11111111             ########
      11111111             ########
      11111111             ########
      01111110              ######
      01111110              ######
      00111100               ####
      00111100               ####
      00011000                ##
      00011000                ##

      where every byte is displayed over two TV lines.


 54273           D401            CHACTL

      (W) Character mode control. See shadow register 755 for values
      that can be POKEd in. Only the least three bits (decimal zero to
      seven) are read, as below:

      Decimal        0     1     2     3     4     5     6     7
      Cursor
      Transparent    X           X           X           X
      Opaque               X           X           X           X
      Present                    X     X                 X     X
      Absent         X     X                 X     X
      ----------------------------------------------------------------------
      Characters
      Normal         X     X     X     X
      Inverted                               X     X     X     X


 54274,5                 D402,3                  DLISTL/H

      Display list pointer. Tells the OS the address of the display list
      instructions about what screen mode(s) to display and where to
      find the screen data. See SDLIST (560, 561; $230, $231).


 54276           D404            HSCROL

      (W) Horizontal scroll enable, POKE HSCROL with from zero to
      16 clock cycles for the number of cycles to scroll. Horizontal fine
      scrolls can be used only if BIT 4 of the display list instruction is
      set. The difficulty in horizontal scrolling lies in arranging the
      screen data to be scrolled in such a manner as to prevent
      wraparound (i.e., the bit or byte scrolled off screen in one line
      becomes the bit or byte scrolled on screen in an adjacent line).
      Normal data arranged for TV display looks like this on the screen:

           +----------+
           |..........|
           |..........|
           |..........|
           |..........|
           |..........|
           |..........|
           +----------+

      where it is a one-dimensional memory area "folded" at the proper
      places to create the image of a two dimensional screen. This is
      done by the DL character or map mode instruction. Without
      other instructions, it reads the memory continuously from the first
      specified location, each line taking the correct number of bytes
      for the GRAPHICS mode specified. To properly scroll it
      horizontally, you must arrange it in relation to the TV screen like
      this:

           +----------+
      .....|..........|.....
      .....|..........|.....
      .....|..........|.....
      .....|..........|.....
      .....|..........|.....
      .....|..........|.....
           +----------+

      Now you will have to make each display instruction for each line
      into a Load Memory Scan (LMS) instruction. To direct each LMS
      to the proper screen RAM for that line, you will have to increment
      each memory location by the total length of the line. For
      example, if you want to scroll a 256-byte horizontal screen, each
      LMS instruction will have to point to a location in memory 256
      bytes above the last one. Of course, you will have to implement
      error-trapping routines so that your screen does not extend
      beyond your desired boundaries.

      Coarse scrolling, one byte at a time, can be done without setting
      the HSCROL register by the method described above. For
      smooth scrolling, you will have to use this register. See De Re
      Atari.


 54277           D405            VSCROL

      (W) Vertical scroll enable, POKE VSCROL with from zero to 16
      scan lines, depending on the GRAPHICS mode of the screen for
      the number of scan lines to scroll. Vertical fine scrolls can be
      used only if BIT 5 of the display list instruction has been set.

      Coarse scrolling can be done without using this register, simply
      by moving the top of the screen address (as defined by the DL
      LMS instruction) up or down one mode line (plus or minus 40 or
      20 bytes, depending on the GRAPHICS mode). The top of the
      screen address can be found by:

      10  DLIST = PEEK(560) + PEEK(561) * 2
         56
      20  SCRNLO = DLIST + 4: SCRNHI = DLIS
         T + 5: REM LSB/MSB OF SCREEN ADDRE
         SS
      25  PRINT "SCREEN ADDRESS = " PEEK(SC
         RNLO) + PEEK(SCRNHI) * 256

      You could then add a routine to this for a coarse - scroll vertically
      through the memory with a joystick, such as:

      30  LOBYTE = 0: HIBYTE = 0
      40  IF STICK(0) = 14 THEN LOBYTE = LO
         BYTE + 40:GOTO 100
      50  IF STICK(0) = 13 THEN LOBYTE = LO
         BYTE - 40
      60  IF LOBYTE < 0 THEN LOBYTE = LOBYT
         E + 256: HIBYTE = HIBYTE - 1
      70  IF HIBYTE < 0 THEN HIBYTE = 0
      80  GOTO 200
      100 IF LOBYTE 255 THEN LOBYTE = LOB
          YTE - 256
      110 HIBYTE = HIBYTE + 1
      200 POKE SCRNLOW, LOBYTE: POKE SCRNHI
          , HIBYTE
      210 GOTO 40
     
      DOWNLOAD VSCROL.BAS

      Coarse scrolling is relatively easy to implement in the Atari: one
      basically alters the screen RAM to display the new material. Fine
      scrolling is more difficult: each scroll register must be POKEd
      with the number of units to be scrolled -- color clocks or scan
      lines -- and the corresponding display list instructions must have
      the proper bits set. This means you can selectively fine scroll any
      mode lines you wish by setting only those bits of the lines you
      intend to scroll. Other lines will be displayed normally. You can
      set a DL instruction for both horizontal and vertical scroll enable.
      See the Hardware Manual for a discussion of the problems in fine
      scrolling.

      Fine scrolling will allow only a certain amount of data to be
      scrolled before the register must be reset (16 clock bits or scan
      lines maximum). In order to make the scrolling activity
      continuous, the register involved must be reset to zero when the
      desired value is reached, a coarse scroll must be implemented
      (usually during a DLI or VBLANK interval) and a new fine scroll
      begun. This is not easily done in BASIC since it is too slow, and
      changing registers during ANTIC's display process usually
      causes rough or jerky motion. Assembly routines are suggested
      for smooth display. See De Re Atari, Micro, November 1981,
      BYTE, January 1982, and Santa Cruz's Tricky Tutorial #2 for
      more information.


 54278           D406            ....

      Unused.


 54279           D407            PMBASE

      (W) MSB of the player/missile base address used to locate the
      graphics for your players and missiles (the address equals
      PMBASE * 256. P/M graphics are tricky to use since there are no
      direct Atari 8K BASIC commands to either create or move them
      (there are, however, commands for P/M graphics in BASIC A+
      and in valFORTH utilities).

      Your P/M graphics must always begin on a 1K boundary
      (PEEK(RAMTOP)-4 for double line resolution players) or 2K
      boundary (PEEK(RAMTOP)-5 for single line resolution), so the
      LSB is always zero (page numbers always end in $XX00). For
      example:

      10   POKE 106, PEEK(106) - 8: GRAPHIC
         S 8: SETCOLOR 2,3,4
      20   POKE 559,62: POKE 53248,100: POK
         E 704,160: POKE 53256,2
      30   MEM = PEEK(106) - 8
      40   POKE 54279, MEM: POKE 53277,3: S
         TART = MEM * 256 + 1024
      50   FOR LOOP = 100 TO 119: READ BYTE
         : POKE START + LOOP, BYTE: NEXT LO
         OP
      60   DATA 16,16,56,40,40,56,40,40,40
      70   DATA 124,84,124,84,254,146,254,1
         70,170,68
      100  END

      You can change the color, width, resolution, and horizontal
      position of the player in the example by altering the registers
      used above.

      Each player is one byte (eight bits) wide. Single line resolution
      P/M characters (POKE 559,62) can be up to 256 bytes high.
      Double line resolution P/M characters (POKE 559,46) can be up
      to 128 bytes high. In either case, they can map to the height of the
      screen. Missiles have the same height, but are only two bits wide
      each. Four missiles can be combined into a fifth player by setting
      BIT 4 of location 623 ($26F). You need not fill the entire height of
      a P/M character, but you should POKE unused bytes with zero to
      eliminate any screen garbage. You can do this by:

      FOR N = PMBASE + 1024 TO PMBASE + 2048:
       POKE N,0: NEXT N

      where PMBASE is the starting address of the reserve memory
      area. In double line resolution, change the loop value to N =
      PMBASE + 512 TO PMBASE + 1024. Here's a short machine
      language routine to do the same thing. You would put the start
      address of the area to be loaded with zero and the number of
      bytes to be cleared in with the USR call as the first two
      parameters. In this example, I have arbitrarily chosen 38012 and
      2048 for these values.

      10   START = 38012: BYTE = 2048: DIM
         PGM$(42)
      20   FOR LOOP = 1 TO 42: READ ML: PGM
         $(LOOP, LOOP) = CHR$(ML): NEXT LOO
         P
      30   DATA 104,104,133,204,104,133,203
         ,104,133,206,104
      40   DATA 133,205,166,206,160,0,169,0
         ,145,203,136
      50   DATA 208,251,230,204,202,48,6,20
         8,244,164
      60   DATA 205,208,240,198,204,160,0,1
         45,203,96
      70   A = USR(ADR(PGM$),START,BYTE)

      You can use this routine to clear out memory anywhere in the
      Atari. You can also use it to load any one value into memory by
      changing the second zero (after the 169) in line 40 to the value
      desired.

      Locating your graphics tables at the high end of memory may
      cause addressing problems for playfield graphics, or may leave
      some of the display unusable and cause PLOT to malfunction. If
      you locate your tables just before the screen display, it may be
      erased if you change graphics modes. You can look at your
      highest RAM use graphics statement and plan accordingly. To
      calculate a safe starting address below the display list, try:

      100 DLIST = PEEK(560) + PEEK(561) * 256: PMBASE =
       INT (DLIST/SIZE -1) * SIZE

      where SIZE is 2048 for single line resolution, 1024 for double
      line.

      Once you have the starting address, determine the ending
      address of your table by adding the correct number of bytes for
      the size (same as the SIZE variable above), and POKE this
      number (LSB/MSB) into APPMHI at locations 14 and 15 ($E, $F).
      This sets the lower limit for playfield graphics memory use. If you
      change graphics modes in the program now, it should leave your
      player tables intact. For example, if the DL is at 39968, the
      PMBASE will equal 36864 in the equation above. Add 2048
      (single line resolution) to get 38912. This is $9800. In decimal,
      the LSB is zero and the MSB is 152. POKE these values into
      APPMHI. This sets the lowest limit to which the screen and DL
      data may descend.

      The unused portion of the RAM set aside for P/M use, or any
      RAM reserved for players, but not used, may be used for other
      purposes in your program such as machine language routines.
      See the appendix for a map of P/M memory use. The register
      stores the address as below:

      Bit                  7  6  5  4  3  2  1  0
      One line resolution: ......MSB.......  ...unused...
      Two line resolution: ........MSB.........  unused..

      There are some restrictions on locating your P/M data above the
      display list. If not positioned far enough above your screen data,
      you may end up with both the normal and screen data being
      displayed at once, resulting in garbage on the screen. A display
      list may not cross a 1K boundary without a jump instruction, and
      the screen display RAM cannot cross a 4K boundary without an
      LMS instruction to point to the proper byte(s). Due to problems
      that arise when moving the GR.7 and GR.8 screens and data less
      than 4K, you should never reserve less than 16 pages above
      RAMTOP in these modes. If you are reserving more, add the
      pages in blocks of 4K (16 pages).
      See COMPUTE!, September 1981, for a discussion of the
      problems of positioning P/M graphics in memory, and using P/M
      graphics for animation.
      See De Re Atari, COMPUTE!, June 1982, and Creative
      Computing, April 1982, for a discussion of using string
      manipulation with P/M graphics. See Your Atari 400/800 for a
      general discussion of P/M graphics. Most of the popular
      magazines have also carried articles on simplifying P/M
      graphics.


 54280           D408            ....

      Unused.


 54281           D409            CHBASE

      (W) Character base address; the location of the start of the
      character set, either the standard Atari set or a user-designed set.
      The default is 224 ($E0), which points to the start of the Atari
      ROM character set. Iridis, a short-lived disk -and- documentation
      magazine, produced a good utility called FontEdit to aid in the
      design of altered character sets. Online Systems' program The
      Next Step is also very useful for this purpose, as is COMPUTE!'s
      "SuperFont," January 1982. Uses shadow register 756 ($2F4).
      Normally, this points to location 57344 or 57856 ($E000 or $E200)
      depending on your choice of characters used in which text mode.
      GRAPHICS mode zero uses the entire 128-character set; GR.1
      and GR.2 use only half the set (64 characters). You POKE a
      different number into the shadow register at 756 ($2F4) to point to
      your own character set in RAM. This must be an even number
      that points to a page in memory that is evenly divisible by two. In
      GR.1 and GR.2 this number is 224 (pointing to $E000), giving
      you uppercase, punctuation and numbers. POKEing the shadow
      or this location (in machine language) with 226 will give you
      lowercase and control characters.
      See the information about the ROM character set at 57344
      ($E000).


 54282           D40A            WSYNC

      (W) Wait for horizontal synchronization. Allows the OS to
      synchronize the vertical TV display by causing the 6502 to halt
      and restart seven machine cycles before the beginning of the
      next TV line. It is used to synchronize the VBI's or DLI's with the
      screen display.
      To see the effect of the WSYNC register, type in the second
      example of a Display List Interrupt at location 512. RUN it and
      observe that it causes a clean separation of the colors at the
      change boundary. Now change line 50 to:

      50  DATA 72,169,222,234,234,234,141,24,208,104,64

      This eliminates the WSYNC command. RUN it and see the
      difference in the boundary line.

      The keyboard handler sets WSYNC repeatedly while generating
      the keyboard click on the console speaker at 53279 ($D01F).
      When interrupts are generated during the WSYNC period, they
      get delayed by one scan line. To bypass this, examine the
      VCOUNT register below and delay the interrupt processing by
      one line when no WSYNC delay has occurred.


 54283           D40B            VCOUNT

      (R) Vertical line counter. Used to keep track of which line is
      currently being generated on the screen. Used during Display
      List Interrupts to change color or graphics modes. PEEKing here
      returns the line count divided by two, ranging from zero to 130
      ($82; zero to 155 on the PAL system; see 53268; $D014) for the
      262 lines per TV frame.


 54284           D40C            PENH

      (R) Light pen horizontal position (564). Holds the horizontal color
      clock count when the pen trigger is pressed.


 54285           D40D            PENV

      (R) Light pen vertical position (565). Holds the VCOUNT value
      (above) when the pen trigger is pressed. See the Hardware
      Manual, p. II-32, for a description of light pen operation.


 54286           D40E            NMIEN

      (W) Non-maskable interrupt (NMI) enable. POKE with 192 to
      enable the Display List Interrupts. When BIT 7 is set to one, it
      means DL instruction interrupt; any display list instruction where
      BIT 7 equals one will cause this interrupt to be enabled at the
      start of the last video line displayed by that instruction. When BIT
      6 equals one, it allows the Vertical Blank Interrupt and when BIT
      5 equals one, it allows the RESET button interrupt. The RESET
      interrupt is never disabled by the OS. You should never press
      RESET during powerup since it will be acted upon.

      NMIEN is set to 64 ($40) by the OS IRQ code on powerup,
      enabling VBI's, but disabling DLI's. All NMI interrupts are
      vectored through 65530 ($FFFA) to the NMI service routine at
      59316 ($E7B4) to determine their cause.

      Bit          7    6     5    4   3   2   1   0
      Interrupt:  DLI  VBI  RESET  .... unused .....  


 54287           D40F            NMIRES

      (W) Reset for NMIST (below); clears the interrupt request
      register; resets all of the NMI status together.


                               NMIST

      (R) NMI status; holds cause for the NMI interrupt in BITs 5, 6 and
      7; corresponding to the same bits in NMIEN above. If a DLI is
      pending, a jump is made through the global RAM vector
      VDSLST (512; $200). The OS doesn't use DLI's, so 512 is
      initialized to point to an RTI instruction and must be changed by
      the user before a DLI is allowed.

      If the interrupt is not a DLI, then a test is made to see if the
      interrupt was caused by pressing RESET key and, if so, a jump is
      made to 58484 ($E474). If not a RESET interrupt, then the system
      assumes the interrupt was a VBLANK interrupt, and a jump is
      made through VVBLKI at 546 ($222), which normally points to
      the stage one VBLANK processor. From there it checks the flag at
      CRITIC (66; $42) and, if not from a critical section, jumps
      through VVBLKD at 548 ($224), which normally points to the
      VBLANK exit routine. On powerup, the VBLANK interrupts are
      enabled while the display list interrupts are disabled. See the end
      of the memory map for a description of the VBLANK procedures.
      For IRQ interrupts, see location 53744 ($D20E).

 ---------------------------------------------------------------------------
 Locations 54288 to 54303 ($D410 to $D41F) are repeats of locations
 54272 to 54287 ($D400 to $D40F).

 ---------------------------------------------------------------------------
 Locations 54784 to 55295 ($D600 to $D7FF) are unused but not empty
 nor user alterable. See the note at 53504 ($D100).

 ---------------------------------------------------------------------------

 OPERATING SYSTEM ROM

 Locations 55296 to 65535 ($D800 to $FFFF) are the OS ROM.
 These locations are contained in the 10K ROM cartridge, which sits in
 the front slot of the Atari 800 or inside the Atari 400. The OS is
 identical for both computers.

 The locations given here are for the "A" version of the OS ROMs.
 There are changes in the new "B" version ROMs, which are explained
 in the appendix. Most of the changes affect the interrupt handler
 routines and SIO. In making these changes, Atari cured some bugs
 such as the device time-out problem. Unfortunately, there is a cloud
 with this silver lining: not all of your old software will run with the new
 ROMs. Megalegs, one of my favorite games, cannot run under the new
 ROMs. A pity that. There are others; I'm sure you'll find them. The
 solution is to have both sets of ROMs so you can use all of your
 software.


 FLOATING POINT PACKAGE ROM

 Locations 55296 to 57343 ($D800 to $DFFF) are reserved for the ROM's
 Floating Point Mathematics Package. There are other areas used by the
 FP package: page zero (locations 212 to 254; $D4 to $FE) and page five
 (locations 1406 to 1535; $57E to $5FF), which are used only if FP
 routines are called. There are also trigonometric functions in the BASIC
 cartridge located between 48549 and 49145 ($BDA5 to $BFF9) which
 use the FP routines. See De Re Atari for more information.

 These are the entry points to some of the subroutines; unless otherwise
 noted, they use FP register zero (FR0 at 212 to 217, $D4 to $DB):


 55296           D800            AFP

      ASCII to Floating Point (FP) conversion.


 55526           D8E6            FASC

      FP value to ASCII conversion.


 55722           D9AA            IFP

      Integer to FP conversion.


 55762           D9D2            FPI

      FP to integer conversion.


 55876           DA44            ZFR0

      Clear FR0 at 212 to 217 ($D4-$DB) by setting all bytes to zero.


 55878           DA46            ZF1

      Clear the FP number from FR1, locations 224 to 229 ($E0 to $E5),
      by setting all bytes to zero. Also called AF1 by De Re Atari.


 55904           DA60            FSUB

      FP subtract routine, the value in FR0 minus the value in FR1.


 55910           DA66            FADD

      FP addition routine; FR0 plus FR1.


 56027           DADB            FMUL

      FP multiplication routine; FR0 times FR1.


 56104           DB28            FDIV

      FP division routine; FR0 divided by FR1.


 56640           DD40            PLYEVL

      FP polynomial evaluation.


 56713           DD89            FLD0R

      Load the FP number into FR0 from the 6502 X,Y registers.


 56717           DD8D            FLD0P

      Load the FP number into FR0 from user routine, using FLPTR at
      252 ($FC).


 56728           DD98            FLD1R

      Load the FP number into FR1 from the 6502 X,Y registers.


 56732           DD9C            FLD1P

      Load the FP number into FR1 from user program, using FLPTR.


 56743           DDA7            FST0R

      Store the FP number into the 6502 X,Y registers from FR0.


 56747           DDAB            FST0P

      Store the FP number from FR0, using FLPTR.


 56758           DDB6            FMOVE

      Move the FP number from FR0 to FR1.


 56768           DDC0            EXP

      FP base e exponentiation.


 56780           DDCC            EXP10

      FP base 10 exponentiation.


 57037           DECD            LOG

      FP natural logarithm.


 57041           DED1            LOG10

      FP base 10 logarithm.

 ---------------------------------------------------------------------------
 Locations 57344 to 58367 ($E000 to $E3FF) hold the standard Atari
 character set: at $E000 the special characters, punctuation and numbers
 begin; at $E100 (57600) the capital letters begin; at $E200 (57856) the
 special graphics begin, and at $E300 (58112) the lowercase letters
 begin.

 There are 1024 bytes here ($400), with each character requiring eight
 bytes, for a total of 128 characters (inverse characters simply manipulate
 the information here to reverse the bits by performing an OR with 128 --
 the value in location 694 ($2B6) when the Atari logo key is toggled -- on
 the bits. To return to the normal ATASCII display, the inverse characters
 are EORed with 128). The first half of the memory is for numerals,
 punctuation, and uppercase characters; the second half ($E200 to
 $E3FF) is for lowercase and control characters. When you POKE 756
 ($2F4) with 224 ($E0), you are POKEing it with the MSB of this address
 ($E000). When you POKE it with 226 ($E2), you are moving the address
 pointer to the second half of the character set. In GR.0, you have the
 entire character set to use. In GR.1 and GR.2, you can use only one half
 of the set at a time. You can't POKE it with 225 because the number
 POKEd must be evenly divisible by two.

 The characters stored here aren't in ATASCII order; they have their own
 internal order for storage. The order of the characters is listed on page
 55 of your BASIC Reference Manual.

 Here's an example of how a letter (A) is stored in ROM. Each line
 represents a byte. The decimal values are those you'd find if you
 PEEKed the eight locations where "A" is stored (starting at 57608;
 $E108):

      Bit   76543210   Decimal
                                 +--------+
            00000000       0     |        |
            00011000      24     |   ##   |
            00111100      60     |  ####  |
            01100110     102     | ##  ## |
            01100110     102     | ##  ## |
            01111110     126     | ###### |
            01100110     102     | ##  ## |
            00000000       0     |        |
                                 +--------+

      When you create your own character sets (or alter the Atari set
      when you move it to RAM -- see location 756; $2F4 for a routine
      to do this), you do a "bit-map" for each character as in the
      example above. It could as easily be a spaceship, a Hebrew
      letter, an APL character, or a face. Chris Crawford's game
      Eastern Front 1941 (APX) shows excellent use of an altered
      character set to create his large map of Russia, plus the symbols
      for the armies.

      Here's an example of using the bit-mapping of the character set
      to provide text in GRAPHICS 8:

      1  GRAPHICS 8
      5  DLIST = PEEK(560) + PEEK(561)*256
      6  LOBYTE = DLIST+4: HIBYTE = DLIST +
         5
      7  REAL = PEEK(LOBYTE) + PEEK(HIBYTE)
        *256: SCREEN = REAL: TV = SCREEN
      10  CHBASE = 57344
      20  DIM A$(128),BYTE(128),WANT(128)
      27  PRINT "INPUT A 40 CHARACTER STRIN
         G:"
      30  INPUT A$
      35  TIME = TIME + 1
      40  FOR LOOK = 1 TO LEN(A$)
      50  BYTE(LOOK) = ASC(A$(LOOK,LOOK))
      51  IF BYTE(LOOK) > 127 THEN BYTE(LOO
         K) = BYTE(LOOK) - 128
      52  IF BYTE(LOOK) < 32 THEN BYTE(LOOK
         ) = BVTE(LOOK) + 64: GOTO 55
      53  IF BYTE(LOOK) < 97 THEN BVTE(LOOK
         ) = BYTE(LOOK) - 32
      55  NEXT LOOK
      59  FOR EXTRA = 0 TO 7
      60  FOR LOOK = 1 TO LEN(A$)
      70  WANT(LOOK) = PEEK(CHBASE + EXTRA
         + BYTE(LOOK)*8)
      80  POKE TV + EXTRA, WANT(LOOK): TV =
          TV + 1
      82  NEXT LOOK
      85  SCREEN = SCREEN + 39: TV = SCREEN
      90  NEXT EXTRA
      100  SCREEN = REAL + TIME*320
      110  IF SCREEN > REAL + 6080 THEN TIM
          E = 0: GOTO 100
      120  GOTO 30
     
      DOWNLOAD BITMAP8.BAS

      This program simply takes the bytes which represent the letters
      you input as A$ and finds their places in the ROM character set.
      It then proceeds to POKE the bytes into the screen RAM, using a
      FOR-NEXT loop.

      To convert ATASCII codes to the internal codes, use this table:

      ATASCII value   Operation for
                      internal code
      0   --  31      add      64
      32  --  95      subtract 32
      96  -- 127      remains the same
      128 -- 159      add      64
      160 -- 223      subtract 32
      224 -- 255      remains the same

      See COMPUTE!, November 1981, for the program "TextPlot"
      which displays text in different sizes in GRAPHICS modes three
      to eight, and January 1982 for a program to edit character sets,
      "SuperFont."

 ---------------------------------------------------------------------------

 Locations 58368 to 58447 ($E400 to $E44F) are the vector tables, stored
 as LSB, MSB. These base addresses are used by resident handlers.
 Handler vectors use the following format:

 OPEN vector
 CLOSE vector
 GET BYTE vector
 PUT BYTE vector
 GET STATUS vector
 SPECIAL vector
 Jump to handler initialization routine (JMP LSB/MSB)

 The device tables in location 794 ($31A) point to the particular
 vector(s) used in each appropriate table. In each case, the 6502 X
 register is used to point to the originating IOCB.


 58368           E400            EDITRV

      Screen Editor (E:) entry point table.


 58383           E40F            ....

      If you PEEK here and get back 56, then you have the older "A"
      version of the OS ROMs. If you get back zero, then you have the
      newer "B" version that was released in January 1982. The "B"
      version fixes some minor bugs, including the device time-out
      problems, enables POKEY timer four, and provides a vector for
      BREAK key interrupts. See Appendix 4.


 58384           E410            SCRENV

      Display handler (television screen) (S:).


 58400           E420            KEYBDV

      Keyboard handler (K:).


 58416           E430            PRINTV

      Printer handler (P:).


 58432           E440            CASETV

      Cassette handler (C:).

 ---------------------------------------------------------------------------
 Locations 58448 to 58533 ($E450 to $E4A5) are more vectors: those to
 location 58495 ($E47F) are Jump vectors, those from 58496 to 58533
 ($E480 to $E4A5) are the initial RAM vectors.


 58448           E450            DISKIV

      Disk handler initialization vector, initialized to 60906 ($EDEA).


 58451           E453            DSKINV

      Disk handler (interface) entry; checks the disk status. Initialized
      to 60912 ($EDF0).


 58454           E456            CIOV

      Central Input/Output (CIO) utility entry. CIO handles all of the
      I/O operations or data transfers. Information placed in the
      IOCB's tells CIO what operations are necessary. CIO passes this
      information to the correct device driver routine and then passes
      control to the Device Control Block (DCB). This in turn calls up
      SIO (below) to control the actual peripheral(s). CIO treats all I/O
      in the same manner: device independent. The differentiation
      between operations is done by the actual device drivers.

      You jump to here to use the IOCB handler routines in ROM.
      BASIC supports only record I/O or one-byte-at-a-time I/O (GET
      and PUT). Addressing CIOV directly will allow the user to input
      or output a buffer of characters at a time, such as loading a
      machine language program directly into memory from a disk file.
      This is considerably faster than using BASIC functions such as
      GET. Here is a typical machine language subroutine to do this:

      PLA, PLA, PLA, TAX, JMP $E456
      (104,104,104,170,76,86,228)
      ($68,$68,$68,$AA,$4C,$56,$E4)

      This gets the IOCB number into the 6502 X register and the
      return address on the stack. CIOV expects to find the IOCB
      number 16 in the 6502 X register (i.e., IOCB zero is zero, IOCB
      one is 16; $10, IOCB two is 32, $20, etc.). $E456 is the CIO
      initialization entry point (this address).

      To use CIOV in a program, first you must have OPENed a
      channel for the appropriate actions, POKEd the correct IOCB
      (locations 848 to 959; $350 to $3BF) with the correct values, and
      established a location in which to load your file (IOCB address
      plus four and plus five). One use is calling up a high-res picture
      from a disk and storing it in the screen memory (locations 88, 89;
      $58, $59). You can POKE the appropriate decimal values into
      memory and call it with a USR call, or make it into a string
      (START$ = "hhh*LVd" where the * and the d are both inverse
      characters) and call it by:

      JUMP = USR(ADR(START$))

      This method is used to start the concurrent mode in the RS-232 of
      the 850 interface in the 850 Interface Manual. See location 88, 89
      ($58, $59) for another example of the machine language routine
      technique. Still another use of this method can be found in De Re
      Atari. Initialized to 58564 ($E4C4).


 58457           E459            SIOV

      Serial Input/Output (SIO) utility entry point. SIO drives the
      serial bus and the peripherals. When a request is placed in the
      Device Control Block (DCB) by a device handler, SIO takes
      control and uses the data in the DCB to perform the operation
      required. SIO takes care of the transfer of data as defined by the
      DCB. CIO (above) is responsible for the "packaging" of the data
      and transfers control to SIO when necessary. See the DCB
      locations 768 to 779 ($300-$30B).
      SIO first sends a command frame to the device, consisting of five
      bytes: the device ID, the command BYTE, two auxiliary bytes for
      device-specific information, then a checksum (which is the sum
      of the first four bytes). If the device acknowledges this frame, it is
      followed, if necessary, by the data frame of a fixed number of
      bytes depending on the device record size, plus a checksum
      byte. Initialized to 59737 ($E959).


 58460           E45C            SETVBV

      Set system timers during the VBLANK routine. Uses the 6502 X
      register for the MSB of vector/times, Y for the LSB and A for the
      number of the vector to hack (change). SETVBV insures that both
      bytes of the vector addressed will be updated while VBLANK is
      enabled. You can JSR here when creating your own timer
      routines. See COMPUTE!, November 1981, for an application.
      Initialized to 59666 ($E912) old ROMs, 59629 ($E8ED) new
      ROMs.


 58463           E45F            SYSVBV

      Stage one VBLANK calculations entry. It performs the
      processing of a VBLANK interrupt. Contains JMP instruction for
      the vector in the next two addresses (58464, 58465; $E460,
      $E461). This is the address normally found in VVBLKI (546, 547;
      $222, $223). It is initialized to 59345 ($E7D1), which is the
      VBLANK routine entry. Initialized to 59345 ($E7D1) old ROMs,
      59310 ($E7AE) new ROMs.


 58466           E462            XITVBV

      Exit from the VBLANK routine, entry point. Contains JMP to the
      address stored in next two locations (58467, 58468; $E463,
      $E464). This is the address normally found in VVBLKD (548, 549;
      $224, $225). Initialized to 59710 ($E93E), which is the VBLANK
      exit routine. It is used to restore the computer to its pre-interrupt
      state and to resume normal processing. Initialized to 59710
      ($E93E) old ROMs, 59653 ($E905) new ROMs.


 58469           E465            SIOINV

      SIO utility initialization, OS use only.


 58472           E468            SENDEV

      Send enable routine, OS use only.


 58475           E46B            INTINV

      Interrupt handler initialization, OS use only.


 58478           E46E            CIOINV

      CIO utility initialization, OS use only.


 58481           E471            BLKBDV

      Blackboard mode entry. Blackboard mode is the "ATARI MEMO
      PAD" mode. It can be reached from BASIC by typing "BYE",
      "B." or by powering up with no peripherals or cartridges.
      Nothing you write to the screen in blackboard mode is acted
      upon by the computer. You can enter this mode to protect your
      programs temporarily from prying and curious fingers.

      All of the screen editing commands continue to work in
      blackboard mode. You can enter blackboard mode from any
      graphics mode with a text window; the display screen will remain
      intact on the screen while the text window will be in blackboard
      mode. Pressing RESET will, of course, return the entire screen to
      GR.0. You can also enter blackboard mode from a program, but
      cannot get out of it in BASIC once you are in it.

      If you entered blackboard mode from BASIC, you can return to it
      by pressing RESET. Any BASIC program will still be there. So
      will any RS-232 or DOS handlers previously booted. Initialized to
      61987 ($F223).


 58484           E474            WARMSV

      Warmstart entry point (RESET button vector). Initializes the OS
      RAM region. The RESET key produces an NMI interrupt and a
      chip reset (see below). Jump to here on an NMI caused by
      pressing the RESET key. Initialized to 61723 ($F11B).


 58487           E477            COLDSV

      Coldstart (powerup) entry point. Initializes the OS and user RAM
      regions; wipes out any program in memory. Initialized to 61733
      ($F125).


 58490           E47A            RBLOKV

      Cassette read block routine entry, OS use only.


 58493           E47D            CSOPIV

      Cassette OPEN for input vector, OS use only.


 58496           E480            VCTABL

      RAM vector initial value table.

 ---------------------------------------------------------------------------

 The following are the addresses for the handler routines:


 58534-59092             E4A6-E6D4               CIOORG

 Addresses for the Central Input/Output routines (CIO):


 58534 ($E4A6) CIOINT

 is the CIO initialization routine called by the monitor on powerup.


 58577 ($E4D1);

 move the user IOCB to the ZIOCB.


 58596 ($E4E4);

 check for a valid command.


 58633 ($E509);

 OPEN command routines.


 58675 ($E533);

 CLOSE command routines.


 58702 ($E54E);

 STATUS and special command routines.


 58729 ($E569) CIREAD;

 process the CIO commands for read and
 write, including buffer check for full or empty.


 58907 ($E61B);

 routine to return to the user from CIO.


 58941 ($E63D),

 routines to compute the device handler entry point,
 jump to the handler, transfer control, and then return to CIO after the
 operation.


 59093-59715             E6D5-E943               INTORG

 Addresses for the interrupt handler routines:


 59123 ($E6F3) PIRQ;

 IRQ interrupt service routines start here.


 59126 ($E6F6);

 the immediate IRQ vector to the IRQ handler. The
 global NMI and IRQ RAM vectors in locations 512 to 527 ($200 to $20F)
 are all initialized to this area (59142, $E706 for the new OS ROMs).


 59314 ($E7B2);

 the vector for the IRQ interrupts on powerup; it
 points to a PLA and RTI instruction sequence (new OS ROMs; 59219;
 $E78F).


 59316 ($E7B4) PNMI;

 the NMI handler, tests for the reason for the
 NMI, then jumps through the appropriate RAM vector. Also called the
 Interrupt Service Routine (ISR).


 59345 ($E7D1) SYSVBL;

 the VBLANK routines start here,
 including frame counter, update timer, update hardware registers
 from shadow registers, update the attract mode counter and the
 realtime clock. The vertical blank immediate vector, VVBLKL1,
 normally pointed to by locations 546, 547 ($222, $223), points to here.
 The Updated OS ROMs point to 59310 ($E7AE).


 59666 ($E912) SETVBL;

 subroutines to set the VBLANK timers
 and vectors.

 The vertical blank deferred interrupt, normally vectored from
 locations 548, 549 ($224, $225), points to 59710 ($E93E). In the
 Updated OS ROMs, it points to 59653 ($E905). In both cases they point
 to the VBLANK exit routine.

 See page 104 of the OS User's Manual for a list of the vectors and
 MICRO, January 1982, for an explanation of the VBLANK process.


 59716-60905             E944-EDE9               SIOORG

 Routines for the Serial Input/Output (SIO) routines:


 60011 ($EA6B) SEND;

 is the SIO send buffer routine entry.


 60048 ($EA90) ISRODN,

 is the serial output ready IRQ vector.


 60113 ($EAD1) ISRTD;

 is the serial output complete IRQ vector.
 This is at 60111 ($EACF) in the new OS ROMs.


 60177 ($EB11) ISRSIR;

 is the serial input ready IRQ vector. This
 is 60175 ($EB0F) in the new OS ROMs.


 60292 ($EB84) CASENT;

 is the start of the cassette handling code
 SIO subroutine to set baud rate, tone values, inter-record gap, to load
 the buffer from the cassette and to turn on the recorder motor. Write
 routines are located in 61249 to 61666 ($EFF5 to $F0E2).


 60515 ($EC63)

 is the start of the disable POKEY interrupts routine
 entry, which also disables the send and receive functions.


 60583 ($ECA7) COMPUT;

 is the subroutine to calculate baud
 rate using the POKEY frequency registers and the VCOUNT timer.
 The tables for the AUDF and VCOUNT values are between 60882 and
 60905 ($EDD2 and $EDE9).


 60906-61047             EDEA-EE77               DSKORG

 Routines for the disk handler.
 Initialization is at DINIT, 60906 ($EDEA), entry is at DSKIF, 60912
 ($EDF0).


 61048-61248             EE78-EF40               PRNORG

 Routines for the printer handler.


 61249-61666             EF41-F0E2               CASORG

 Routines for the cassette handler.

 The buzz used in the cassette CLOAD command can be called up from
 BASIC by:

 BUZZ = USR(61530).

 You can turn it off with the RESET key. While this isn't terribly
 exciting, it points to the potential of using the console speaker for
 sound instead of merely for beeps (the RAM location for the speaker is
 at 53279; $D01F). See the speaker location and COMPUTE!, August
 1981, for a short routine to use the speaker for sound effects.


 61667-62435             F0E3-F3E3               MONORG

 Routines for the monitor handler. This is also the address area of
 PWRUP, the powerup module (61733; $F125). Coldstart routines are
 initialized to this location. The routine to check for cartridge
 installation begins at 61845 ($F195). Hardware initialization begins at
 62081 ($F281).


 61723 ($F11B) RESET;

 the RESET button routine starts here.


 62081 ($F281) HARDI,

 the start of the hardware initialization
 routines.


 62100 ($F294) OSRAM;

 the start of the OS RAM initialization
 and setup routines.


 62159 ($F2CF) BOOT;

 the entry point for the disk boot routine.


 62189 ($F2ED) DOBOOT;

 the disk boot routine activation.


 62334 ($F37E) DOPEN;

 the entry point for the reinitialization
 of disk software.


 62436-65535             F3E4-FFFF               KBDORG

      Routines for the display and keyboard handler. The display
      handler beqins at 62454 ($F3F6) and the keyboard handler
      begins at 63197 ($F6DD), below.


 63038           F63E            EGETCH

      Like the BASIC INPUT command, EGETCH gets a line from the
      screen and keyboard, but only one character at a time. You must
      do a JSR $F63E for each character input. This is also the address
      of the beginning of the screen editor routines.


 63140           F6A4            EOUTCH

      This routine puts the character currently in the accumulator onto
      the screen in the next print location. Similar to the BASIC PUT
      command.


 63197           F6DD            KGETC2

      Beginning of the keyboard handler.


 63202           F6E2            KGETCH

      This routine waits for a key to be pressed and returns its value to
      the accumulator (6502 register A). Similar to the BASIC GET
      command.


 64428           FBAC            SCROLL

      The screen scroll routine starts here.


 64764           FCFC            DRAW

      Screen draw routines begin here, end at 65092 ($FE44). See
      Creative Computing, March 1982, for an example of a
      modification to the draw routines to avoid the "out-of-bounds"
      error for use in GR.7+.


 65093-469               FE45-FFBD               ....

      The ROM tables for display lists, ANTIC codes, control codes,
      and ATASCII conversion codes.


 65470           FFBE            PIRQQ

      Subroutines to test the acceptance of the last key pressed and to
      process the debounce delay routines start here.
      When a key is pressed, it initiates an IRQ through VKEYBD at
      locations 520, 521 ($208, $209) to 65470 ($FFBE). This is the
      keyboard service routine. It processes debounce, and SHIFT-
      CTRL logic (see location 559; $22F); saves the internal keyboard
      code in 754 ($2F2) and 764 ($2FC); sets the ATTRACT mode flag
      at 77 ($4D) and sets location 555 ($22B -- SRTIMR) to 48 ($30).


 65528           FFF8            CHKSUN

      According to Softside Magazine, December 1981, if a PEEK here
      returns 255, then you have the older OS ROM(s). There were
      some troubles with cassette loads in the older ROMs that
      sometimes require the following to cure:

      Do an LPRINT without a printer attached before CLOAD. This
      clears the cassette buffer.

      Press RESET before CSAVEing or CLOADing will restore the
      system to its initialization parameters and help with loading and
      saving routines.

      There is a new OS available from Atari which fixes a bug that
      would cause the I/O operations to "time out" for a few seconds. It
      apparently does not alter any of the routines mentioned here.

      The chip reset interrupt (powerup) vectors through location
      65532 ($FFFC) to 58487 ($E477) where a JMP vector to the
      powerup routine is located. A chip reset is not the same as
      pressing the RESET key, which in itself does not generate a chip
      reset.

      The NMI interrupts are vectored through 65530 ($FFFA) to the
      NMI service routine (ISR) at 59316 ($E7B4), and all IRQ
      interrupts are vectored through 65534 ($FFFE) to the IRQ service
      routine at 59123 ($E6F3). In these service routine areas, the
      cause of the interrupt is determined, and the appropriate action
      is taken, either by the OS or through a JMP to a RAM vector
      where a user routine exists.

     ----------------------------------------------------------------------

   Return to Table of Contents | Previous Chapter | Next Chapter

    

    

    

    

    

   [IMG]
   [IMG]