RAMDOSII (c) 1996 by wilf rigter

                   Adapted for use with XTender (c)


      The easy way for Sinclair ZX81 (and XTender) users to

      organize storage of data and speed up program development.





The Tiny RAMDisk Operating System (RAMDOSII) is a simple file management

program to name, save, load, merge or erase BASIC programs and variables,

MC programs, and data files in a 32K RAMDISK. It has 15 build-in single key

functions and can be expanded with new "transient" commands.

Using RAMDOSII, the user can create a LIBRARY of programs, variables and

data files in the on-board nonvolatile RAMDISK.  The RAMDISK is organized

as a directory of 32 files complete with file names,  file type and file length.

Simple cursor control selects the desired file, and with a single keystroke,

the file is transferred between the RAMDISK memory and  the system memory.

Amazingly compact, RAMDOSII assembles to 512 bytes of relocatable object

code and comes complete with a fully annotated source listing. RD2 Source Code

RAMDOS is normally used with a large Non-Volatile Memory pack or the ZX97.

Here RAMDOS2 has been adapted for the XTender1 program for demonstration.


For a detailed description of each command read the section on RAMDOSII but

for a short exploration of the RAMDOSII system continue with this section.


Here is a zip file with the RAMDOS2 program and banks: RAMDOS2.ZIP


XTender users should start XTenders and LOAD "RAMDOS2"  and enter 00-03 for

the bank number. The loading screen reminds users of the simple command set.

Press any key and voila the RAMDISK directory. The > cursor points to the

first file in the RAMDISK.  Note that RAMDOSII commands only require the first

letter of each command to be entered except "E"rase which must be shifted for

security and the "N"ame command must be followed with 7 characters of text

which includes numbers, letters, punctuation, and leading or trailing spaces.





First practice returning to the BASIC operating system by pressing Q and then

press "T" (RAND) followed by " enter" (N/L) to return to the directory. While

in the BASIC edit mode, the keyword RAND is used as a hot key to access

RAMDOSII.  Next practice loading and running programs. The first program that

we will load from the RAMDISK is the DELPHIC program in directory 00. To

select the DELPHIC file use the 5,6,7,8 keys. Once the cursor is positioned in

front of the desired file just press "L" and "R" to load and run the program.

All BASIC programs can be interrupted by pressing the "space" key to cause a

break. Next practice saving a BASIC program. Select a position in the

directory to save the program with keys 5 to 8. Notice how the cursor moves

left, right, up and down and wraps around the ends of the directory.




Saving a BASIC program is as simple as pressing "B" and when saved, the file

type and file length pops up in the directory and the file is now in the

RAMDISK ready to be loaded back into SYSTEM RAM when it is required. Note that

the save operation nondestructively copies a file from SYSTEM MEMORY to the

RAMDISK. To name this new file press "N" and then type "DEMOTWO" or any other

7 characters. The current letter to be typed is shown in reverse and after the

7th character, the screen flashes to indicate the name command is complete.

Line edit functions or back space is not available for this procedure. If you

make a mistake while entering the name, just continue to the 7th character and

then you can RENAME by repeating the same procedure typing over an old name to

change it.



We have already learned to save, name and load an existing BASIC program (B

file). Let's continue and experience writing and saving your own BASIC

program. First break the current BASIC program by pressing space bar on the

keyboard. Then press NEW to erase the System Memory and "Q"uit the directory.

Next enter a few lines of BASIC code such as :




This is just a short BASIC program to show that you can save your own

programs.  Then press RAND and select directory 4. Move the cursor to the

position in the directory where you wish to save it. Next press the "B" key to

save this BASIC program and notice the file type and length change. Also

notice that all other files are moved over to make room for the new file.  Now

press the "N" key and type in WELCOME. You have just saved and named your own

BASIC program in RAMDISK. Now press Q to quit and go back to BASIC.          


Next we try out the B file LOAD command. Press NEW to clear SYSTEM RAM and to

return to the directory. Now position the cursor, using cursor keys (5,6,7,8),

to point to the WELCOME file. Press L once to load WELCOME into the SYSTEM

RAM. Then press "R" to demonstrate the autorunning quit command.




Next we can demonstrate the possibility to MERGE multiple B files by pressing

Space,  then RAND to return to the directory. Again position the cursor using

cursor keys (5,6,7,8) to point to the WELCOME file. Press L once more to load

a second copy of the WELCOME B file. Then use "Q" to quit and LIST to see 2

identical copies of the short BASIC program in the SYSTEM RAM. The clone was

generated by MERGING the original with the copy loaded from the RAMDISK.


Simple LOADING occurs if the SYSTEM RAM had no previous BASIC program in it

when LOADING a B file from RAMDISK. MERGE occurs, as we just demonstrated,

when there is an existing BASIC program in the SYSTEM RAM, when loading any

other B file from RAMDISK .


The procedure for saving and loading BASIC VARIABLES is identical to B file

operations except that the letter "V" is used to save the VARIABLES to a V

file. Experiment with DIM A$(1000) and then save this array to the RAMDISK

with "V". Note the file size includes the variable name length etc. To do a

simple V file LOAD, use the BASIC command CLEAR to erase the VARIABLES before

loading a V file. To MERGE, simply DO NOT CLEAR existing VARIABLES before

loading the V file.


The procedure for saving and loading MC programs to M files is identical to B

file operations BUT MC PROGRAMS MUST BE FORMATTED before saving and loading.

Read the example in INSTALLING RAMDOSII and RAMDOSII:SAVING M files before

attempting any M file operations.


Continue as you like with this exercise by loading some of your favorite

programs from EPROMDISK and saving them to RAMDISK until you feel familiar

with the procedure for loading and saving, erasing and naming files in the

RAMDISK. Then, for more information and program examples read the RAMDOSII





The RAMDOSII software is designed to be compact, relocatable, and easy to use.

It speeds up the process of saving and loading programs to "instantaneous". It

is a tool for merging programs, subroutines and variables to aid program



RAMDOSII contains the following one key commands:           


                  1.(B)asic Program Save to RAMDISK.                   

                  2.(V)ariable Area Save to RAMDISK.                  

                  3.(M)achine Code  Save to RAMDISK.                 

                  4.(N)ame or rename file in Directory.                 

                  5.(E)rase (shift E) file from RAMDISK.                 

                  6.(L)oad file from RAMDISK.

                  7.(Q)uit RAMDOSII and return to calling program.            

                  8.(R)un - quit RAMDOSII and GOTO 1 of BASIC program.        

                  9.SPACE BAR - quit and break to BASIC edit mode.             

                  10.Left, right, up, down arrows move the cursor.            

                  11.Keys "0" and "1" select directories.


The letter in brackets is the single key used to execute the command , (N)ame

must be followed by seven characters of text. The screen flashes as it is

updated after each command is executed. For security (E)rase must be used

together with the shift key.





Additional commands are provided as transient utility routines as described



Although there is no explicit Write Protect disable command before SAVING,

NAMING and ERASING, the control register WRITE bit is set just before these

commands modify RAMDISK memory and is immediately reset afterwards. Attempting

to POKE a byte in the RAMDISK (32K-64K) from BASIC, will not work unless you

first set the WRITE bit in the control register with POKE 5E3,128. However if

DIP switch S1 is on then the RAMDISK memory is unconditionally write





The RAMDISK directories of 32K each are loaded into an area of the memory map

normally not used by BASIC or ML programs.

The RAMDISK is used in the same way as a floppy or hard drive, but is much

faster. The current directory is located between 32K and 64K as shown in FIG

1. The directories are organized as shown in FIG 2. Note the way that files

are packed together with no waste of storage space. There are no minimum size

sectors or fragmented memory to worry about. The actual location within the

current directory is usually of no interest since the files are loaded into

system memory before they are actually used. If required the memory address of

the file to which the cursor is pointing, is passed back to BASIC in system

variables 16507 (LSB) and 16508 (MSB) after quitting RAMDOSII and returning to





When RAMDOSII prints the current directory to the screen, it reads the control

register and prints the directory number to the top left hand corner of the

screen. It reads and prints the first file name and type from start of 32K

directory and masks bytes to make sure that the name and type are printable

characters .(<CHR$64)


Next it reads and prints the file length and calculates the location of the

next file header.  It continues to print out all the file names it can read

until it reaches the 32nd file.  The order of the file names on the screen is

left to right, top to bottom corresponding to the first to last position in

memory.  Depending on the contents of the directory, there may be some blank

files names showing in the directory before or after any files which have

actually been saved.  For example, a empty directory generates a screen full

of "       ;     0" files indicating that the current directory memory is all

zeroes. (ie spaces).  The RAMDISK memory can be initialized with NULL bytes

using the CLRDISK utility. (see TRANSIENT COMMANDS)





The unshifted 5,6,7,8 keys are repeat action cursor keys. They move the

inverted > cursor around the directory to select files by name. The unshifted

1 and 2 keys select 1 of 8 directories scanning forwards or backwards. Note

that the cursor and directory keys roll over after reaching the first and last

file or directory. The location in the current directory of the file pointed

to by the cursor is stored in System Variables 16507/8 and this may be used as

a parameter by other programs.




When saving files either the write enable push button must be held down or the

write protect switch must be in the closed position. The memory map shown in

FIG 1 indicates the portions of memory which are saved to RAMDISK using the B,

M, and V commands. The structure of the file types is shown in FIG 3-5 . The

header for each file  is 10 bytes : 7 bytes for name, 1 byte for type, and 2

bytes for length.  Saving files is a simple procedure of entering the file

name followed by the letter B, V, or M representing file type to be save.

First the cursor is positioned in the desired location in the directory. After

pressing B, V, or M, the files after the cursor will be moved over one

position by the new file, thereby overwriting the 32nd file if it contained

valid data. Only after a file has been saved can the file can be named.




We save a BASIC file by simply pressing "B" and the directory will now show

the "B" for BASIC type and the length of the file. The B file (BASIC file) is

compact because it only includes  BASIC lines but not the display or





Saving BASIC VARIABLES separately provides a powerful means of transferring

data files from one program to another, and allows a program to periodically

backup it's BASIC VARIABLES without the need to save the program itself.  Some

BASIC programs don't initialize their BASIC VARIABLES and therefore won't

operate if the VARIABLES are not retained.  In that case both a B file and a V

file must be saved, generally using the same NAME, and these must also be

loaded together in order to properly execute the program. Remember NOT to use

the RUN command since this will clear the BASIC VARIABLES.  V files are saved

by pressing "V" after which the "V" type and length are displayed in the

directory. The VARIABLES in the SYSTEM RAM are only copied into the RAMDISK

and are not cleared.




Saving and loading Machine Code programs presents some problems primarily

because of the lack of standards for the structure and location of MC

programs. MC programs reside and run anywhere below 32K , some above RAMTOP,

some as part of a BASIC program in the first line of BASIC, some in the last

line of BASIC. In addition many programs are written to run between 8K-16K. In

order to reduce the complexity of dealing with MC program it is convenient to

standardize three run locations.


       1. The MC programs developed with the bundled Z80 assembler can be run

from the BASIC area as part of a BASIC program. These M/C programs are stored

in a 1 REM line and the transient commands and control demonstration programs

are good examples. This type of MC program is very easy to deal with since it

is by definition a B file and should be saved and loaded as such.  This type

of MC program is conceptually the simplest.


      2. MC programs generated by the Z80 assembler which run from the 8K-16K

area must be formatted as 1 REM lines, organized as shown in FIG 4. Note that

the actual code is preceded with a 2 byte address which is the location of the

first byte of code when loaded into it's RUN LOCATION. After formatting this

program is saved as an M file. Note that the address used when calling the

program (RAND USR NN) is not necessarily the same as it's RUN LOCATION

address. A good example of this type of MC program is the Z80 disassembler

which is transferred to RUN LOCATION 8192 when loaded. The Z80 disassembler is

started with RAND USR 1E4.


      3. Some M/C programs run above RAMTOP, the highest memory address used

by the BASIC program, which means that RAMTOP must be lowered prior to loading

the M file above RAMTOP. The Z80 assembler can generate such program by

preceding the code with the RUN LOCATION address as shown in FIG 4. The

program is saved as an M file. The Transient command RTPLOAD can be used to

lower RAMTOP.(see TRANSIENT COMMANDS) If already present above RAMTOP this of

type MC program can copied from above RAMTOP into a formatted 1 REM line by

using the REMSAVE transient command and can then be saved as an M file. The

Z80 assembler is an example of this type of MC program. When saving an M file

the MC program must be in the following format: The Machine Code must be

located in the FIRST BASIC LINE as shown in FIG 4. This is the location of the

Machine Code product of some ASSEMBLER programs and the location for many MC

programs after they are loaded from tape.  In addition the first 2 bytes of

the MC program right after REM, 118, 118 must be the RUN LOCATION address for

that MC program.  This is no problem if you are the MC programmer and you can

simply precede the SOURCE CODE with the RUN LOCATION bytes before assembling

the OBJECT CODE. It is also possible to convert existing MC programs to M

files, by stripping off the relocating utility and adding the necessary RUN

LOCATION bytes.  (Also see WRX16 HIRES, and Transient commands REMSAVE,





When naming files either the write enable push button must be held down or the

write protect switch must be in the closed position. After saving a new file,

the file length and file type appear in the directory but the name field is

still blank. In order to name a file the user simply presses (N)ame and enters

the 7 character name including any leading or trailing spaces. The current

letter to be typed is an black square. All printable non-inverted characters

may be used. After entering the 7th character the screen flashes to indicate

the name command is finished. If you make a mistake while entering the name

continue to the last character and then repeat the procedure to rename the

file.(Backspace is not provided) To RENAME an old file, point cursor to the

old file name and then use the same procedure as for a new file name. If NVM

write protection DIP switch (S1) was OPEN or the write enable button not held

down while entering the name, then the name will disappear after entering the

7th character.




The type of each file may be changed with the "T"ype command which highlights

the file type and changes it to the next character entered with the keyboard.

This is primarily useful to change M files to B files so they can be merged

with existing BASIC programs.  Another use is to lock files by changing the

file type to a character other than B, V, or M. Such files can not be loaded

or erased and are therefore considered locked. The last letter of the file

name should be changed to the original type in order to remind the user when

unlocking the file by returning the file to the original file type. The "T"ype

command must be used with great caution aside from the two applications

mentioned to avoid a system crash when attempting to load converted files.



The single "L" (LOAD) command transfers all types of files from the RAMDISK to

various locations in the System Memory. Just move the cursor to point to the

desired file name and then press L.   Like SAVING there are 3 types files that

can be LOADED as follows:




BASIC files are loaded into the System Memory area between the System

Variables and the Display. (FIG 1) The BASIC Variables are not affected by a

Bfile Load which allows the user to combine existing BASIC Variables with new

programs.  There are two cases of loading a B file, namely LOADING and

MERGING, which occur as a result of the initial conditions of the B file LOAD.




If there is NO BASIC program in the BASIC area prior to Load ( as would be the

case if the user had deleted all lines or executed a NEW) then once Loaded.

the B file will be the only BASIC program and it will Autorun from line 1 on

exit from RAMDOSII. (Like GOTO 1)  

 Remember that some BASIC programs may not execute properly if started at

Line 1.  If necessary add a line of BASIC such as 1 GOTO NN to the program

where NN is the start of that BASIC program, before to Saving to RAMDISK. 



If there is already a BASIC program in the BASIC area before Loading a B file,

then after Loading there will be two (or more) merged programs in the BASIC

area with the latest B file MERGED ahead of the other programs. This is called

BASIC MERGING and the combined program will NOT Autorun. B files are merged

AHEAD of existing BASIC program lines rather than behind  for several reasons:


 1. Transient MC programs in 1 REM, which are used as commands, may be LOADED

(merged), run with RAND USR 16523, and deleted with "1" without disturbing the

existing basic program. Transient Commands usually are MC programs that were

saved as B files and when loaded can run from the BASIC area.  2. When writing

a BASIC program,  universal subroutines stored in the RAMDISK can be loaded as

required during the program development keeping in mind that subroutines run

faster if located at the beginning of the basic program. 3. A merged program,

before renumbering, can be easily Listed and Run if it is located at the start

of the BASIC program area.  A transient Command RENUMBR is required to

give merged program lines unique line numbers. It is included in RAMDOSII

BASIC and must be extracted and saved to an M file before it can be used as

a transient command (see TRANSIENT COMMANDS).




Select the V file to be transferred  from the RAMDISK to the System Memory

using the cursor keys. The selected V file is transferred to the BASIC

variable area between the end of the Display area (VARS) and the Work space

(E-LINE) when pressing L.  Variables are loaded or merged depending on initial





Only one set of variables will exist after a V file LOAD if there were no

previous variables in the variable area.  This is true right after power-up ,or

if no variables have been defined , or after CLEAR, RUN and NEW.  BASIC

programs are not affected by V file LOAD except for the impact that the new

variables values may have on the program.   Some BASIC programs were saved

together with BASIC variables, in order to execute properly. Such programs

must be loaded together with their variables.  The order of loading is not




If a set of BASIC variables existed prior to LOADING then the V file will be

merged AHEAD of the existing BASIC variables.   This means if two or more

variables have the same name then only the latest variable can be accessed. 

There is no utility such as RENUMBER available for merged variables and the

merged variables should therefore have unique names prior to saving.    It is

possible to separately delete array variables using DIM XX (0) while leaving

the other BASIC variables intact. This may prove useful in some applications.




When loading a M file, two things are assumed :


 1. That the M file was prepared in accordance with the M file SAVE



 2. The area pointed to by the RUN LOCATION bytes is free.  

Since any first BASIC line can be saved as a M file it is possible to generate

a M file which has a random run-location, which if loaded may cause a system

crash. M files which have a RUNLOCATION above RAMTOP may be loaded only after

RAMTOP is lowered. A transient command, RTPLOAD, lowers RAMTOP to the value of

the RUNLOCATION. M files do not necessarily contain MC programs but may also

contain HIRES files, or 2040 printer pattern tables or any other data. Great

care must be taken to avoid a system crash due to the inherent unconstrained

addressing of the RUN LOCATION of MC programs and the way MC programs can

alter critical unprotected areas of the system .




When erasing files either the write enable push button must be held down or

the write protect switch must be in the closed position. In order to conserve

space or to update files it is sometimes necessary to erase the old files.

This is done by pointing the cursor at the file to be erased and pressing

(E)rase while pushing the write protect button. The files located after the

erased file are moved up to fill the gap and an equivalent new space is

created at the end of the RAMDISK. If a file cannot be erased is possible

that random data in the length field makes the file appear to be too long so

that erase would cross the END of the RAMDISK. In that case push the file off

the end of the directory by inserting small files in front of the long file or

clear to END using the transient command CLRDISK. 



When the user wants to exit RAMDOSII simply press Q. The position of the

cursor can be peeked at 16507/8 and used to determine free RAMDISK or as a

parameter for the transient programs. Newly loaded B files may autorun after

Q, as described in BASIC LOAD. If RAMDOSII was called from within a BASIC

program using for example  100 RAND USR 7685 then if a V file or M file was

loaded it continues to run after Q or if a B file was loaded an error break

will occur.




You can use RAMDOSII and transfer files from within a BASIC or MC program.




It is simple to add a program line to any BASIC program and call RAMDOS by

entering, for example, 100 RAND USR 32691. That address, as you can see, is

5 bytes more than 32K. This skips a test which RAMDOSII uses to filter the

keyword RAND in BASIC programs while that program is in the RUN mode.  On

execution the Directory will appear and M files and V files can be loaded as

required. Quit will return to the next BASIC program line which continues

uninterrupted. If RAMDOSII is called from within a BASIC program and a B file

is loaded, then this will result in a merge of the calling program and the B

file  which will result in an error break after you quit RAMDOSII.   To return

to the calling Basic program always use "Q"uit. If the call was a function

like LET A=USR 7685 then the value which is returned is the address of the

first byte of the current file name to which the cursor was pointed before

quitting. MC PROGRAMS

MC programs can JUMP or CALL the RAMDOSII program at address 1E07 (7687d).

Once in the DIRECTORY you can transfer files etc. B files can be LOADED  but

only if the calling MC program is not located in the BASIC area . Because

RAMDOSII was written in relocatable Machine Code it can be merged with any

other MC program and run from any location in memory.  The various places  for

locating MC programs are:  in the Enhanced ROM, 8K-16K,  above RAMTOP or in

any BASIC program line. To return to the calling program always use "Q"uit or

"Space" since "R"un will force a restart from the first basic line. On return,

the BC register pair holds the address of the first byte of the file header to

which the cursor was pointed when quitting.




Transient commands for RAMDOSII, which are commands or functions that

are SAVED as B files and are LOADED or MERGED when needed to perform

the required commands. The RENUMBR, UNMERGE, CLRDISK and FREERAM

programs are examples of these transient command programs and are included

with the development software. Any other utilities such as HEX/DEC conversion

can be easily added by the user to suit his own particular requirements.

In general these transient commands are MC programs that are used infrequently,

for a short time and are deleted after use. They may be MERGED with, but do not

interfere with, existing programs in the SYSTEM RAM. If a transient command

consists of a single 1 REM line with a MC program then it is deleted after use with

1, N/L.  If the command is written in multiple BASIC lines then the UNMERGE

command is used to reduce these multiple lines to  a single 1 REM line which

can be deleted with 2 keystrokes.


The UNMERGE routine is for use  with multiple line BASIC transient programs to

allow such multiple line BASIC programs to be deleted with only a few

keystrokes while leaving the original BASIC program intact. UNMERGE is MERGED

with the  transient command program which must end with  9998 RAND USR 16523

and 9999 STOP When used the Transient command is executed with GOTO 1 and when

finished, the UNMERGE command will take all lines between 1 and 9999 and

include them in a  single 1 REM line which can then be deleted with 1, N/L. 


The RENUMBR command will renumber merged BASIC program lines in increments of

10 but will not change GOTO's or GOSUB's. Just LOAD RENUMBR and RAND USR 16523

After that press 10 and N/L to delete the RENUMBR utility and remember to

change all those GOTO's and  GOSUB's.


The FREERAM command returns the space remaining in the RAMDISK from the cursor

to the end of the RAMDISK. After Loading FREERAM from the directory, position

the cursor after the last file of interest, Quit and  then use PRINT USR 16523

to print the number of bytes remaining from the end of the last file to the

end of the RAMDISK.


The CLRDISK command is used to clear all or part of the RAMDISK to  00. There

is no way to recover the data after it has been cleared and therefore CLRDISK

must be used with care and attention. After Loading CLRDISK, position the

cursor to point to the location in the  directory  after the last file of

interest and Quit.




Use RAND  USR 16523 to run the CLRDISK command. Remove the 1 REM line

which contains CLRDISK with 1 and N/L. Go to the directory to reset the write bit.

The REMSAVE command is used to transfer an MC program from above RAMTOP

to a 10 REM line, automatically formatted with the appropriate RUNLOCATION

bytes and ready to be saved as a M file. Use RAND USR 16523 to run.


The RTPLOAD command is a companion to REMSAVE when loading M files above

RAMTOP. In that case load RTPLOAD and leave the cursor pointing to the M file

to be  transferred to above RAMTOP. This M file must have a VALID RUNLOCATION

ie  somewhere between  RAMTOP and 32K and must have been saved using the

REMSAVE  command . Next Quit and RAND USR 16523 will lower RAMTOP to the

required value followed by an automatic NEW. Then LOAD the M file in the usual







The Z80 Assembler program is "L"oaded into 8k-16K memory as a Mfile.

Thereafter it can be executed with RAND USR 8192.

The generated source code in 2 REM can be saved to a Bfile before assembly.

The executable code in 1 REM can be saved as a Mfile or as a Bfile. Appendix A

provides the full instructions.



The disasssembler is installed with a simple load to the area between 8192 and

xxx. The program is executed with RAND USR 1E4. The following functions are



1. "D"isassemble.

2. "L"ist data in HEX and Sinclair format.

3. "S"earch for a two byte string.

4. "C"ontinue listing or disassembling.

5. "Z"=copy disassembled code to a 2 REM file.


The disassembler was written by Harvey Taylor and slightly modified by me to

dump the output to an assembler source code file. Before using the "Z"

function, the user must first load a Assembler compatible 2 REM line. If

necesary, install and run the Assembler program to create a 2 REM line. The

disassembled code which appears on the screen is transferred when pressing "Z"

and is appended to any existing source code in the 2 REM line. Multiple

screens can be transferred this way. The only changes the user must make

before assembling this disassembled source code is to translate the hex offset

that accompanies the IX and IY instructions to decimal code. code. This minor

shortcoming stems from the peculiar requirement  of the assembler for decimal

offsets. The 2REM2REM utility can be loaded and run with RAND USR 8192 to

merge two 2 REM lines into one 2 REM line. This is a great way to create

macros or a library of subroutines which can be merged into a single source

file before editing with the assembler.



The ZXTERM80 terminal program was written by Fred Nachbaur and includes

ZMODEM upload and download capability . It is a HIRES program which displays

up to 80 columns of ASCII or Sinclair Code. The instructions are in appendix B.




The program NOVA 1000 is included which provides a BASIC

line trace utility and a real time clock which run concurrently with any other

application program. This makes it easy to write time or clock oriented

control programs. The details to NOVA are provided in the NOVA article .