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.


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.


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.


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.


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).


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.


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


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.


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).


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


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


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).


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.


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


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.


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.


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).


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). ------------------------------------------------------------------------


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


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.


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).


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.


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.


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).


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).


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.


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


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.


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.


The value of E (the exponent).


The sign of the FP number.


The sign of the exponent.


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.


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. ---------------------------------------------------------------------------


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. ---------------------------------------------------------------------------


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).


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.


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


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).


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.


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


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.


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. ---------------------------------------------------------------------------


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


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.


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. MEMLO">

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. ---------------------------------------------------------------------------


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).


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.


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.


GET byte routines, including GET file routines. 2817 B0l DFMSTA Disk STATUS routines.

2837 B15 DFMCLS

IOCB CLOSE routines.


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


RENAME a file.

3122 C32 XDELETE

DELETE a file.


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


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.


List the disk directory.


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".


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. ---------------------------------------------------------------------------


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). ---------------------------------------------------------------------------


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. ---------------------------------------------------------------------------


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.


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. ---------------------------------------------------------------------------


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.


(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.


(R) Missile 1 to playfield collision.

53250 D002 HPOSP2

(W) Horizontal position of player 2.


(R) Missile 2 to playfield collision.

53251 D003 HPOSP3

(W) Horizontal position of player 3.


(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.


(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.


(R) Player 1 to playfield collisions.

53254 D006 HPOSM2

(W) Horizonal position of missile 2.


(R) Player 2 to playfield collisions.

53255 D007 HPOSM3

(W) Horizontal position of missile 3.


(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)


(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.


(R) Missile 1 to player collisions.

53258 D00A SIZEP2

(W) Size of player 2.


(R) Missile 2 to player collisions.

53259 D00B SIZEP3

(W) Size of player 3.


(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.


(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.


(R) Player 1 to player collisions.

53262 D00E GRAFP1

(W) Graphics for player 1.


(R) Player 2 to player collisions.

53263 D00F GRAFP2

(W) Graphics for player 3.


(R) Player 3 to player collisions.

53264 D010 GRAFP3

(W) Graphics for player 3.


(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.


(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).


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

53267 D013 COLPM1

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


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

53268 D014 COLPM2

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


(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. ---------------------------------------------------------------------------


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.


(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.


(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.


(R) Pot 2 (626).

53763 D203 AUDC2

(W) Audio channel two control.


(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.


(R) Pot 4 (628).

53765 D205 AUDC3

(W) Audio channel three control.


(R) Pot 5 (629).

53766 D206 AUDF4

(W) Audio channel four frequency.


(R) Pot 6 (630).

53767 D207 AUDC4

(W) Audio channel four control.


(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.


(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.


(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.


(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 ....


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.


(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).


(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).


(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). ---------------------------------------------------------------------------


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 ....


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 ....


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.


(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). ---------------------------------------------------------------------------


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.


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.


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.


The screen scroll routine starts here.


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.


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).


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