
EPROM+ TUTORIAL

This tutorial is provided to fully acquaint you with the commands and features
of your EPROM+ programming system. Our experience indicates that many
customers, in an effort to quickly perform a task with their system, don't
read the manual and never take the time to fully explore the capabilities of
their system. The EPROM+  has a rich set of commands and features which, when
fully understood, make most any task you need to perform fast and easy.

WHAT YOU WILL NEED FOR THIS TUTORIAL
Before you begin, you will need to have the EPROM+ programming unit connected
to a computer and the AC adapter connected to a power outlet. The green power
led should be lit. The tutorial is based on a 28F256 or 28F256A EPROM. We
suggest that you use a 28F256 as this is a flash device and can be erased
using the programming unit instead of a serarate eprom eraser. If you do not
have a 28F256, you may substitute another device, however the ending addresses
given in the examples will not be correct and should be adjusted based on your
chip's actual capacity.

BEFORE WE GET STARTED
The EPROM+ software is fully compatible with DOS, WIN3.1, WIN95 and WIN98.
The tutorial assumes a standard DOS environment either within windows or
directly executing under DOS.  For the tutorial we will be running the program
from the floppy disk inserted in drive A. If you have installed the software
on your hard drive or are running from a different drive other than A:, make
the necessary substitutions as you progress through the tutorial.  The syntax
used in the tutorial indicates both what you will see on the computer's screen
and what you should type as a response. Information from the computer is shown
in doube quotes.  An example is "ENTER BUFFER STARTING ADDRESS ->". Information
entered by you is shown in curly brackets. An example is {7FFF<ENT>}. We
indicate non-character keys by enclosing them between less than (<) and
greater than (>) signs. The  ENTER key would appear as  <ENT> while the space
bar would appear as <SP>. This means that when you see {7FFF<ENT>} you type
7FFF and press ENTER. The EPROM+ software is designed to use as few obscure
functions as possible. There are a only a few occasions where the ALT and
SHIFT keys are required. These are indicated as <ALT> and <SHIFT> which means
you hold down the alternate (ALT) or shift (SHIFT) key while the required 
character key is pressed. As an example, the PATH command allows you to add
a directory to the currently logged drive and path. This is accomplished by
pressing ALT A. The tutorial will represent the key sequence as {<ALT A>}.
This means you hold down the ALT key and then press A. Remember that the ALT
and SHIFT keys are always pressed and held before the second key is pressed.

Each session of the tutorial is independent. This means that you may work as
long as you desire and then pick up where you left off. The only requirement
before you reenter a session is that you must initialize the system to its
fundamental start up status or the state of the system when you last stopped.
This is accomplished by performing the LET'S GET STARTED part of the tutorial.
Obviously if you exit the tutorial during operation on the contents of a
device or file you must reload the device contents or file before you could
continue. We assume common sense on your part.

LET'S GET STARTED
The first step is to start the EPROM+ software.  The control program is called
PEP and can be executed from the DOS prompt or by using the RUN command under
windows. Insert the floppy disk which came with your system into drive A. If
you are running under DOS type {A:<ENT>}. Type {PEP<ENT>}. If you are running
under windows use the RUN command and BROWSE to drive A. Select the application
PEP and click OK.  PEP will start and display the screen which indicates the
printer port to which the programming unit is connected. You will see a message
indicating the available buffer space and also a message which states
"THERE IS NO SYSTEM CONFIGURATION FILE". This is normal. We will cover how to
create a configuration file later in the tutorial.

SELECTING AND ENTERING THE DEVICE PART NUMBER
The system now displays a list of device part numbers called the
DEVICE SELECTION TABLE. These are all the parts the EPROM+ system currently
supports. Note that the table is organized by technolgy family (eproms,
eeproms, flash eproms, etc.) There are several pages of device technology
families which you may view using the PAGE UP <PgUp> and PAGE DOWN <PgDn> key.
Note that there is a lite bar in the upper left corner of the screen. There
are two methods from which you may choose to select a device part number. The
first is to simply type the part number. In the lower left corner of the
device selection table is the prompt "ENTER DEVICE TYPE->" Enter the number
of the part you are using (28F256). The system will accept your part, process
the part number and display the main screen. You may also select a part
number using the lite bar. Use the arrow keys to move the lite bar within a
technology family catagory. Press <TAB> to move the lite bar to a different
catagory. Once the lite bar is over the part number, press <Ins> to select
the device.

THE MAIN SCREEN
This  main screen is where you perform all major system operations.
Let's take a moment to discuss each screen area. In the center and most
visible is the COMMAND LIST. These are all the commands from which you may
choose to perform any operation you require. A command is selected by pressing
it's corresponding number or letter key. In the lower part of the main screen
is a single window which is divided into two parts. The left part is for
command and data entry. This is where the system will prompt you for
information and where you will respond. Look here if you are ever in question
about what the system requires. The right part of the window displays system
activity and status. Any activity in which the system is engaged will be shown
here. For example, when a device such as an EPROM is being programmed, this is
where the byte counter is displayed. If you are in question about what the
system is doing, look here. The left and right sides of the lower window
perform two specific functions thereby allowing you to focus your attention
to one specific screen area for information. The upper part of the main screen
contains a single long window. This window displays information specific to
the device you have selected. The information displayed includes the device
(part number), device size (storage capacity in bytes shown as a range) and
the device programming voltage. Look here if you need specific information
about the part with which you are working. Before we continue be aware that
the lower window is also used as a general purpose display for system
information which is not command or activity oriented.

A WORD ABOUT THE DIP SWITCH
At this point you have entered your the part number and have the main screen
displayed. Note that the part number is now displayed in the upper left
corner along with its size (0-7FFF) and the programming voltage (Vpp). In the
lower window the system displays the dip switch setting for the programming
unit. The setting is shown as eight arrows numbered 1 through 8 pointing up
or down. An up arrow means the corresponding dip switch is on or up. A down
arrow means the corresponding dip switch is off or down. Set the switchs on
the programming unit according to the settings illustrated in the display.
The system will show the correct dip switch setting whenever the device with
which you are working is changed.

ON TO THE COMMANDS
To clear the dip switch setting from the lower window press any key. The
system now responds with "SELECT COMMAND ->". This is the prompt you will
see whenever the system is waiting for you to choose an operation. Before we
explore the commands specific to working with your eprom, let's first
familiarize you with how the EPROM+ system works with disk directories and
files. The EPROM+ uses the FAT16 file system for maximum compatibility with
all operating systems. Folders are called directories and any directory you
create with the EPROM+ software will appear as a folder in Windows.

THE PATH COMMAND
The path command allows you to view and move about the entire directory
structure of any drive installed in your computer. The path command
does not display files. Files are displayed using the DIRECTORY COMMAND.
The EPROM+ software treats the disk structure as a path to the file or
files with which you wish to work. It is important that you understand
this concept.  Like a path through the woods, you must set the path to your
files. The path command only sets the path (starting at the root directory
and moving through subdirectories) to your files; it does not allow you to
perform any file related operations. To begin lets examine the CURRENT PATH.
The CURRENT PATH is the path which the system is using to access your files.
Press {P}. The main screen will clear and be replaced with the path screen.
Note that in the center of the screen is the message "NO DIRECTORIES". As
this is the EPROM+ distribution disk, it has no directories, only files.
Let's view some directories. If your computer does not have a hard drive
skip to THE DIRECTORY COMMAND. In the lower left corner of the screen is
the prompt "ENTER NEW DRIVE/PATH->". Press {[ALT V]} and type {C}. This
changes the path screen to view your hard drive (drive C). At this point
you should see at the top of the path screen the message
"DIRECTORIES IN ROOT" beneath which is a list of all the directories in
the root (starting level) of your hard drive. In the upper left hand corner
of the list there is a light bar. Use the arrow keys and move the light bar
through the list of directories. As the light bar moves, watch the single
line window just below the list of directories. On the left you see
"NEW DRIVE/PATH = " followed by the drive and path selected by the light bar. As the light bar moves you will see the
directory name over which the light bar is placed appear as the
"NEW DRIVE/PATH".  Look to the far right in the same window as NEW DRIVE/PATH.
You will see either a light blue "NO SUBDIRECTORIES" or a light red
"SUBDIRECTORIES". If there are no subdirectories below the currently hi-lited
directory, the "NO SUBDIRECTORIES" indicator is displayed. If there are
subdirectories below the current directory, the "SUBDIRECTORIES" indicator
is shown. Move the light bar over the different directory names and see if the
"SUBDIRECTORIES" indicator appears. If it does, press the TAB key to move down
to the next directory level. You will see the "NEW DRIVE/PATH" change to
reflect the addition of the next directory name. If you wish to move back up
to the previous directory level press <SHIFT TAB>.  Once you have moved into a
lower directory level, any directories in that level will be shown. This is
how you navigate through the disk directory structure. Once you have
established the path to your final destination directory, press the <Ins> key.
The path to that directory will immediately become the new CURRENT PATH for
your session. It is important to remember that all you have done is use the
PATH command to set the path through the disk directory structure which points
to the final destination directory where your files are located. The PATH
command has nothing to do with files. Because you are working from a floppy
disk, this tutorial does not include examples of working with the other
features of the PATH command which allow you to add and remove directories.
Adding and removing directories is a powerful feature which gives you the
ability to create a directory and log chip data directly to a file of your
choice within that directory.

A VIEW FILE SHORT CUT - The PATH command does allow you a quick short cut to
view files in the hi-lited directory. To view the files press <ALT D>. This
causes the system to automatically set the hi-lited directory and it's
associated path as the CURRENT PATH. The system then jumps to the DIRECTORY
command to display the files.  To try this press <ALT D>.  You are now viewing
files in the destination directory of the CURRENT PATH. The DIRECTORY command
is covered next but it is important that you are aware of this short cut as it
is very handy. To return to the PATH command press <ALT P>. 

If you need help at any time press {ALT H} to display a brief PATH command
summary. This concludes the PATH command section of the tutorial. Please take
a moment and read the PATH command section in the user manual and practice
both adding and removing directories.

Before you exit the PATH command press {[ALT V]} and then {A} at the
"ENTER NEW DRIVE LETTER->" prompt to set the systems path back to your
floppy drive. Now press <ESC> to return to the main command list.

THE DIRECTORY COMMAND
The directory command lists the files in the current directory.
Press the {D} key.  As you are now logged onto your floppy drive (A:) all the
files on the disk are shown. Look at the upper left corner of the screen.
You will see "DIRECTORY OF A:". In the upper right corner of the screen you
will see "RECALL FILENAME = NONE". Note that the word NONE is red. This means
that no filename is available for you to recall. Recall filenames are shown
in yellow. If there was a file called NONE it would be yellow.
The RECALL FILENAME will be discussed later in the directory tutorial.
Using the arrow keys, move the light bar over the file TESTFILE.BIN. Press
the <Ins> key. Note that the name TESTFILE.BIN appears directly after the
"ENTER FILENAME FOR RECALL->"  in the bottom left corner of the screen.
Press <ENT>. This accepts the filename and exits the command. Press {D} again.
Note that now in the upper right corner of the screen the RECALL FILENAME
indicates TESTFILE.BIN. If you wish, you may type a name at the prompt.
It does not have to be selected using the light bar. Note that you have
just assigned TESTFILE.BIN as the RECALL FILENAME. You could also have
done the same thing by typing TESTFILE.BIN at the "ENTER FILENAME FOR RECALL->"
prompt.

HANDY SHORT CUTS - There are three short cuts available from the DIRECTORY
command. When you use this command you usually want to load a file into the
buffer or program a device from a file. Therefore you may access either
operation directly from the DIRECTORY command. Look to the right of the
"ENTER FILENAME FOR RECALL ->" prompt.
You will see "(FILE: [ALT-1] PROGRAM [ALT-4] LOAD)". Pressing <ALT-1> will
take the hi-lited file directly from the directory screen and jump to 
COMMAND 1 (program device from disk file). Pressing  <ALT 4> will take the
hi-lited file and load it into the buffer  using COMMAND 4 (read disk file
into buffer). You may also switch directly to the PATH command by pressing
<ALT P>. Performing the short cuts is beyond the scope of this tutorial as 
the actual command operation has not yet been explained, however once you
begin using the system you will find them very handy. Also note that for
the short cuts we use the actual command numbers and letters in conjunction
with the ALT key as these are easy to remember.

This concludes the tutorial for the PATH and DIRECTORY commands. We strongly
suggest that you use these commands to move about your computers disk drive.
Move down directory levels then back up. View the files you find in the
directories and subdirectories. After you complete the tutorial of COMMAND 4,
you will be able to load files and look at the contents.

INSERTING DEVICES INTO THE PROGRAMMING UNIT
The next set of commands requires that you use your EPROM. To insert your
EPROM into the socket first release the socket by raising the handle to a
fully vertical position. With the socket released, align the notch on the
EPROM so that it faces the same direction as the red dot on the socket.
Assuming that you have a 28F256 part, it will have 32 pins and fully occupy
all of the available pins in the socket. Drop it into place and release the
socket handle (horizontal position). The EPROM is now locked into place. If
you have a 27256 (28 pins) or smaller device, be sure to left justify the
part in the 32 pin socket. Reference the diagram in the lower left corner
of the programming unit. 

COMMAND 1 - PROGRAM DEVICE FROM DISK FILE
The purpose of COMMAND 1 is to allow you to program a device or series of
devices directly from a disk file. This command eliminates the process of
first loading a file and then instructing the system to program. To begin
press {1}.  Note that the command description on the main screen changes to
reverse video and the "1" begins to flash (the "1" may not flash under
windows). This indicates that the command is selected and currently active.
Look at the lower  window under COMMAND/DATA ENTRY. You see the message
"CURRENT PATH = A:". This tells you where on your computer the file will be
obtained. Below CURRENT PATH is the prompt "ENTER FILENAME->". This is where
the RECALL FILENAME is very handy. Look to the right and note the prompt
"(PRESS Ins TO RECALL FILENAME)". This is a hint to remind you to that if you
have preset a RECALL FILENAME using the DIRECTORY command it may now be used.
Press the <Ins> key. The name TESTFILE.BIN appears directly after the
ENTER FILENAME-> prompt. Press <ENT>. The software begins processing the file.
While the file is being processed the system displays the message
"PROCESSING BINARY FILE..." in reverse video. Once the file is processed the
sofware displays under ACTIVITY/STATUS three items. At the top is the number
of devices required to hold the file. For the file TESTFILE.BIN the number of 
devices is 1. One line below you are instructed to "INSERT DEVICE NUMBER 1". 
You have already placed your EPROM into the socket so this step is complete.
The bottom line tells you "DEVICE STARTING ADDRESS = 0". This is where the
first byte in the EPROM will be programmed from the buffer. If you need more
information about this message refer to the user manual. The last step is to
actually program the EPROM. In the lower left corner of the screen you are
prompted with "PROGRAM OR SKIP (P/S)->". Press {P}. The system will begin to
program the data from the file into the EPROM.  While the programming process
is active, you will see "PROGRAMMING DEVICE ---" on the right side of the
screen with "BYTES REMAINING=" directly below. The BYTES REMAINING= is a
counter which counts down toward 0 as the EPROM is programmed. This lets you
monitor the programming process. Note that the lower two digits remain as FF
until the upper digits become 0. The upper digits only change every time 256
bytes are programmed. This reduces the amount of time the system must spend
updating the counter. When the count reaches 0, you will see the system
display the message "VERIFYING DEVICE AFTER PROGRAMMING" in reverse video.
At this time the system is comparing the data just programmed into the EPROM
with the original data in the buffer. This is a double check to guarantee that
the device is indeed programmed properly and that it's data matches that in the
buffer.  After the EPROM has been verified, the message "PROGRAMMING COMPLETE"
 - "DATA VERIFICATION IS CORRECT" is displayed under ACTIVITY/STATUS. You are
now prompted with "FINAL DEVICE-" "PROGRAM ANOTHER SET? (Y/N) ->". Press {N}
to terminate the command. You have just programmed data from the file
TESTFILE.BIN into your EPROM.

NOW ON TO READING
At this point you have an EPROM programmed with data from your file. The next
part of the tutorial will illustrate the variety of commands and features which
can be used with programmed parts. Before we go into great detail about the
command we will first clear the buffer. The buffer is where data is placed
before it is programmed into the EPROM and also where data is placed when an
EPROM is read. The buffer is accessed with the BUFFER EDITOR. Enter the
BUFFER EDITOR by pressing {5}. The BUFFER EDITOR is covered later in the
tutorial but at this time note the screen of data. This is the data that was 
just programmed into the EPROM. Press {C} to invoke the CLEAR BUFFER command
then press {1} to clear the buffer to all FF (binary 11111111). Note that the
data vanishes and replaced with a screen of FF's. Press {Esc} to exit the
buffer editor.

COMMAND 3 - READ DEVICE INTO BUFFER
Command 3 allows you to read a device into the buffer. It also has options
which allow you to selectively place the data from the device exactly where
you wish. The tutorial for Command 3 will illustrate the fundamental command
operation plus option 1 (user defined load address) and option 2 (read user
defined zone). If your EPROM is not already installed in the socket, install
it now. Press {3}. You will see the system prompt
"READ DEVICE AT BUFFER START (ADDRESS 0)" "(Y/N/(O)PTIONS)->". Press {Y}.
The system will respond with "READING DEVICE...." as data from the EPROM is
loaded into the buffer. Note that in it's fundamental state, COMMAND 3 always
places the data into the buffer beginning at buffer address 0 (the first
location in the buffer). When the contents of the EPROM have been read into
the buffer, the command terminates. Press {5}. This invokes the buffer editor
and allows you to view the data loaded from the chip. Note that it is exactly
the same as was loaded from the file. If you want to view the contents of any
part this is the exact procedure you would use. Press {C} then {1} to clear the
buffer back to FF. Press {Esc} to exit from the editor.

The next step is to use option 1 to read the data from the EPROM into the
buffer at some address other than 0. For this exercise we will load the
data from the EPROM beginning at buffer address 100. Press {3}{O}{1}.
You now see "USER DEFINED LOAD ADDRESS" "ENTER BUFFER STARTING ADDRESS ->".
Type {100<ENT>}. You are prompted with "READ (Y/N) ->". Press {Y}. Wait until
the read operation is complete. Press {5}. When you view the data you will
see all FF's. Press {PgDn}. PgDn causes the editor screen to scroll down one
page of data (a page is 256 bytes). Note that at buffer address 100 (upper
left corner of data) the data from your EPROM begins.  You have just
instructed the system to load the data from the EPROM at a buffer address
other than 0. Press {PgUp}. This moves the buffer display up 256 bytes
where there is no data from your EPROM. Press {C}{1} to clear the buffer for
our next exercise.

Our next exercise uses option 2 (READ USER DEFINED ZONE) to read a small
portion of the data in the EPROM and place it at a specific address in the
buffer. Press {3}{O}{2}. You will see "LOAD DEVICE ADDRESS RANGE (ZONE READ)"
"ENTER DEVICE STARTING ADDRESS->". Type {20<ENT>}. You are prompted with
"ENTER DEVICE ENDING ADDRESS->". Type {3F<ENT>}. You are prompted with
"ENTER BUFFER STARTING ADDRESS->". Type {80<ENT>}. Respond to "READ (Y/N)->"
with {Y}. The command executes almost immediately. Press {5}. Note that the
data containing the words ANDROMEDA RESEARCH has been read from the EPROM
and placed in the buffer beginning at address 80. This is a very powerful
command as it allows you to take a block of existing data in an EPROM and
selectively copy it into the buffer at any location you choose. This
concludes the tutorial for command 3.

COMPARING DATA
This exercise illustrates how the EPROM+ system compares an existing EPROM
with data loaded into the buffer. To begin, place your programmed EPROM into
the socket. Press {3}{Y}. This reads the data from the EPROM into the buffer.
Press {8}. This is the COMPARE DEVICE WITH BUFFER command. You will see
"COMPARE FROM BUFFER START (ADDRESS 0)" "(Y/N/(O)PTIONS) ->". Press {Y}.
You will see "COMPARING DEVICE WITH BUFFER" in reverse video while the
comparison is in process. When the comparison is complete, you will see
"COMPARISON COMPLETE:000000 ERROR(S)". "- PRESS ANY KEY TO CONTINUE -".
This indicates that the data in the device was an exact match with the data
in the buffer. Press {Esc} to terminate the command. We will now alter two
bytes of data in the buffer using the buffer editor.
Press {5}{M80<ENT>}{5555<Esc>}. This changes the data at buffer addresses 80
and 81 from 2A to 55. (Just a hint about how the editor works; M is for Modify,
80 is the buffer address to change and 55 is the data we entered. As you
pressed the keys, you saw the data change.) Press {Esc}. Press {8}{Y}. When
the comparison completes, note that the result is different. You see
"COMPARISON COMPLETE:000002 ERROR(S)". To the left you are prompted
with "EXAMINE ERRORS? (Y/N) ->" Press {Y}.  The system will now show
you each error with the buffer data and the corresponding device data
displayed. To view the next error, press {C}. Each error occurance is
displayed until no further errors are encountered. Command 8 is an easy
way to compare the contents of two chips or a chip with a file. All you
have to do is load the buffer with one set of data and use the compare 
function with the device in the socket. This concludes the tutorial for
Command 8.

SAVING A CHIP TO DISK
This exercise illustrates a command unique to the EPROM+ system; the
ability to log the contents of a device directly from the socket on the
programming unit to a disk file. Insert your programmed EPROM into the
socket.  Press {D}. This should display the directory of drive A. If not
use the PATH command to change the path to drive A. Type {LOGFILE.BIN<ENT>}.
This sets LOGFILE.BIN as the RECALL FILENAME. Press {B}. This invokes the
SAVE DEVICE TO DISK FILE command. You are prompted for a filename. Press {Ins}.
The name "LOGFILE.BIN" appears. Press {<ENT>}. You are prompted with
"SAVE DEVICE IN SOCKET NOW?" "(Y/N/(O)PTIONS) ->". Press {Y}. You will see
"SAVING DEVICE TO DISK FILE.." as the EPROM data is logged to the file
LOGFILE.BIN. When the operation is finished you will see
"* DEVICE SAVE OPERATION COMPLETE *". Press any key.  Press {D}.
This displays the directory of drive A. Notice that the file LOGFILE.BIN
is now present. Press {Esc}. This is an extremely easy way to log parts
and thereby create libraries of devices without archiving the original 
chips. Before we conclude this part of the tutorial we will use the
REMOVE/DELETE FILE command to remove the file LOGFILE.BIN from drive A.
Press {R}. Press {<Ins><ENT>}. You are prompted to "REMOVE FILE NOW? (Y/N) ->".
Press {Y}. You will see the message "* FILE DELETED *" after the file is
removed. If you wish, press {D} to verify that the file is indeed gone.
This concludes the tutorial for Command B.

UTILITY COMMANDS
Before we continue, there are a few commands which allow you to perform some
special tasks. Although we won't spend a great deal of time in exercises, it
is important that you understand how these commands operate.

SAVE THE BUFFER
Command A allows you to save all or part of the buffer contents to a disk file.
Although it is easier to use Command B to log the contents of a chip, there may
be times when you have data in the buffer which you have combined from multiple
files or edited and you want to save your work. Let's assume this is the case. 
Press {A}. The system requests that you provide a filename under which the
buffer data will be saved. Type {BUFDATA<ENT>}. You are prompted with
"SAVE DEFINED BUFFER RANGE". If you wanted to save the buffer range which
corresponds to the size of the chip, you would press Y. For this exercise
we'll specify a buffer range. Press {O}. You are prompted for the buffer
starting address. Type {0<ENT>}.  This establishes the first address in
the buffer which will be saved to the file. Now enter the ending buffer
address. Press {FFF<ENT>}.  This establishes the last buffer address which
will be saved to the file. Just for your information 0 to FFF is 4K or 4096
bytes. You are now prompted to SAVE (Y/N/(O)PTIONS) ->. Press {Y}. The system
saves the buffer data beginning at 0 and ending at FFF to the file. When the
save operation is complete the command terminates. Press {D} to view the
directory and note that the file BUFDATA now exists. For practice set
BUFDATA as the RECALL FILENAME and then use the R Command to delete the file.
If you don't remember how, position the light bar over the filename (BUFDATA)
and press {<Ins><ENT>R<Ins><ENT>Y}. The file is deleted. Command A also lets
you save the buffer as a printable image. This is done by choosing the OPTIONS
selection after SAVE and then specifying ASCII.

CALCULATING A CHECKSUM
A checksum is the sum of bytes in a device or file. It is normally displayed
as a 16 bit (4  hex digits) integer value. It can also be calculated over a
partial range of a device or file, but usually when a checksum is specified,
it's for the total device or file. The DEVICE/FILE CHECKSUM command allows
you to do both. Place your programmed EPROM into the socket. Press {K}{1}.
Respond to the DEVICE IN SOCKET prompt with {Y}. The system will apply power
to the socket and calculate the checksum (sum all the bytes in the chip).
Note the message "CALCULATING CHECKSUM..." while the operation is in process.
When the calculation is complete the system displays a results summary. Note
that there are three results. SUM; this is the standard checksum and the one
to which most people refer when a checksum is requested. ONES COMP; this is
logical compliment of the SUM. TWOS COMP; this is the ones compliment plus 1.
There are reasons, primarily for programmers, that the ONES and TWOS
compliment results are displayed but you will probably never need them.
If your EPROM is programmed correctly the results are SUM=B93C, ONES COMP=46C3,
TWOS COMP=46C4. We will now perform a checksum of the file TESTFILE.BIN. To
perform the operation, load the file into the buffer. We will use Command 4 to
load the file. Press {<Esc>} to exit the command. Press {D}. Position the lite
bar over the filename TESTFILE.BIN. Press {<Ins><ENT>}.
Press {4}{1}{<Ins>}{<ENT>}. This invokes Command 4 and uses option 1
(load file at buffer address 0) to load the file. Note that after the
file is loaded, the system displays a summary of where the file was actually
loaded into the buffer. Command 4 provides a very powerful set of options for
a variety of file processing operations. They are beyond the scope of this 
tutorial but take time to review their operation as described in the manual.
TESTFILE.BIN is now loaded into the buffer. Press {<Esc>}. Invoke the Checksum
command again. Press {K}{3}. Note that the same summary is displayed and that
the results are identical to those obtained from the EPROM.

Why have a checksum? Although not of the highest reliability, a checksum is a
simple, easy to calculate value which indicates whether or not the data in the
chip or file has changed. For example, when a chip is created, the checksum is
calculated and recorded or written directly on the chip label. If at some
future time the chip becomes suspect, it is a simple matter to remove the part
and perform a checksum calculation in a system such as the EPROM+. If the
checksum matches the recorded value, the chip is assumed to be good. If a
different checksum is obtained, the data in the chip has changed.

DEVICE OPTIONS
Device options are any extra features a part has which are specific only to
that part. The 28F256 EPROM you have been using has one option. This is the
electrical erasure of the part. As a point of interest, the term FLASH
originated in that the parts erased in a flash, not programmed in a flash.
The EPROM+ system provides one command which changes function depending
upon the device you have selected. This is the DEVICE OPTIONS (Z) command.
Insert your EPROM into the socket. Press {Z}. You are asked to confirm that
the device is in the socket. Press {Y}. The system proceeds to erase the
device and then verifies that the erase operation was successful. If the
operation completes successfully you are notified with
** FLASH DEVICE ERASED **. Before you remove the EPROM from the socket,
let's perform a manual erase check. This is accomplished using Command 6.
Press {6}. The system requests that you confirm that the device is in the
socket. Press {Y}. You will see "VERIFYING DEVICE IS ERASED..." while the
erase status of each byte is verified followed by
"*** DEVICE IS ERASED ***" when the operation concludes. For practice,
take a programmed EPROM and use command 6 to test the erased status.
Before we leave DEVICE OPTIONS, lets look at one other device which has some
different options. Press {Esc}. Use Command 9 and choose the 16C54 PIC
microcontroller. Press {9}. Type {16C54<ENT>}. Press {<SP>} to clear the
dip switch change information.  Press {Z}. Note the options available for
this part. Do not make any changes but note how the command works. Whenever
a device with any options is selected, the Z Command adapts itself to allow
you to work directly with those options. Press <Esc> to exit the options
command. Use Command 9 to again select the 28F256 EPROM. Press {9}.
Type {28F256<ENT>}. This concludes the DEVICE OPTIONS tutorial.

PROGRAMMING A DEVICE FROM THE BUFFER
As you know, the buffer is where data is placed before it is programmed into
a device. Data gets into the buffer in one of three ways; from a device
installed in the socket (Command 3), from a disk file (Command 4) or by
manually entering the data using the buffer editor (Command 5). We will now
use Command 2 to program the 28F256 which you previously erased. If the
buffer contains no data, load TESTFILE.BIN using Command 4 option 1. Once the
file is loaded, insert your EPROM into the socket and press {2}{Y}. The system
first verifies that the device is erased and then begins the programming 
process. When the programming is complete, the system verifies the data in the
chip against the buffer as a double check and then indicates the result. If
the chip programmed correctly you will see "PROGRAMMING COMPLETE"
"DATA VERIFICATION IS CORRECT". At this point you may remove the programmed
chip from the socket. This concludes the Command 2 tutorial.

ALMOST DONE WITH THE MAIN COMMANDS
There are a few more main commands which are of interest but are extremely
simple in their function.  These are Command 7 - COPY DEVICE,
Command F - DISPLAY/SELECT PROGRAMMING ALGORITHM and
Command V - MANUALLY SET PROGRAMMING VOLTAGE.  Each of these commands are
described in the manual. Normally you will not need to alter the programming
algorithm or change the programming voltage as these settings are predetermined
when the device is selected. Command 7 is a dedicated function specifically to
copy a part. It is combination of Command 3 and Command 2. Simply follow the
instructions when the command is selected.

SETTING UP A CONFIGURATION FILE
The last item before we begin the tutorial for the buffer editor describes how
to set up a configuration file. The EPROM+ system lets you create a special
file which defines five system settings: PATH, FILE, DEVICE, COMMAND and
DISPLAY. By creating a configuration file, you can eliminate the repetitive
steps you perform each time you use your system. The settings contained in the
configuration file will automatically be applied when the system starts. The
configuration file is created using the options selection under
Command 0 - EXIT PROGRAM. Press {0}{O}. The lower window changes to
EDIT/SAVE SYSTEM CONFIGURATION FILE with each of the system setting
descriptions.  You could, if you wish, type into each field after the
description a path, file, device, etc. It is easier, however to have the
system to retrieve the information for you. Press {<ALT>U}. Note that the field
following each description is filled with the current system setting. All
fields are filled except COMMAND=. The COMMAND= field must be specifically
set by you. If you always load a specific file when you start your system
press {<TAB>} until the cursor is located following COMMAND= and press {4}.
If you wanted the system to program a device from a disk file you would
press {1}. This sets the command that will be executed when the system starts.
Note that the entire command is not executed, it is just a though you had 
pressed the command number from the keyboard at the main screen. You have now
retrieved and entered all the settings for the configuration file. Any settings
you do not specify are not preset when the system starts and must be entered
manually. Press {<ALT>S}. The configuration file is saved and will be used 
the next time you start the program. To try this out press {0}{Y}. Now
restart the program by typing {PEP<ENT>}.  Notice that the system starts,
automatically selects the device and you are already at Command 4 awaiting an
option selection. Press {1}{<Ins>}. Note that the path and filename are also 
preset. Press {<ENT>}. The system loads the file into the buffer. At this
point you are ready to begin your work. Before we conclude this tutorial,
a few words about the configuration file. The file is always called PEP.CFG.
It must reside in the same directory as the control program PEP.EXE. If you
wish to remove the file you can use the Path command to navigate to the
directory where the configuration file is located and then use the
Command R - REMOVE/DELETE FILE  to delete the file from your system. Any time 
you make any changes to the system, you can use ALT-U to recall your changes.
When you save the new configuration the old file will be overwritten.

This concludes the tutorial for the main commands. There are other functions
included in many of the commands which are beyond the scope of this tutorial.
It is strongly suggested that you take time to read the manual and fully
explore these additional features.

The final part of the tutorial covers the buffer editor. If you are only
interested in basic reading and programming of chips plus loading and
saving files, you may end here. Although some previous references were made
to the buffer addresses and data, you do not need to be an expert on using
the editor or it's commands to perform most common device operations.
If, however, you have an interest which extends beyond basic programmer
functions, the editor tutorial will acquaint you with capabilities and 
features which allow you to perform extremely detailed data work.

THE BUFFER EDITOR, A WORLD OF BYTES, BITS AND WORDS
Before we begin the tutorial of the buffer editor, it is important that you
understand exactly what the buffer is, where it is located and how it is
organized. The buffer is a dedicated block of your computer's memory which is
specifically allocated and organized to serve as the primary storage location
for data which is to be transferred to or loaded from a device. The buffer is
organized as a series of individual bytes of data.  A byte of data is 8
individual bits which can be either a 1 or a 0. Each byte in the buffer is 
located at an address. The address is a number which identifies where the byte
is actually stored. Think of the address as similar to the address which
identifies the location of a house. A house address is a number which
specifically selects one individual home on an entire street. The buffer
address is the same, it is a number which specifically identifies an
individual byte from all the other bytes in the buffer. If all this seems
a bit confusing, let's view the data in the system's buffer. Press {5}.
Although you've seen this before, I'll point out the specific features
of the editor screen. If the buffer has data remaining from a file or your
EPROM press {C}{1}. The data area of the screen should be all FF.  Before we
dive into the editor and it's commands it is very important that you
understand some fundamental concepts. These concepts are address and data,
which we touched on before, binary, hex and decimal numbers plus ASCII
(pronounced "ASK HE"). The approach I will use to explain the concepts
uses the editor to do the illustration. This seems to be the most direct
approach to illustrate the fundamentals that you need for your foundation.

JUMP RIGHT IN WITH ADDRESSES AND DATA
Press {M}{0}{<ENT>}. Notice that the upper left window which before displayed
"EDITOR MODE=BYTE" now shows "0 FF-". Also note that just to the right of the
top 0 in the far left column the FF has changed to reverse video (We'll call
this reverse video block the EDIT CURSOR). Here's what this means. The 0 means
address 0 which is the first buffer location. The upper left window is called
the EDIT WINDOW. This is where you both view and enter data. Note that the FF
after the 0 is the same as the FF under the edit cursor. Let's change it.
Type {55}. Note what happened, the FF became a 55. The edit cursor moved one
place right and now in the edit window you see "1-FF". You are now at buffer
address 1, the data at buffer address 1 is FF. Lets change it. Type {33}. You
should now have the picture. Each group of two characters (like the FF's) is
a single byte of data in the buffer. The editor screen is organized as
16 lines of 16 bytes. The cyan numbers at the far left of the editor screen
show the address for the first byte in that line. These addresses are in hex
not decimal, but we'll cover that later. Let's do one more change.  Press the
down arrow key twice. Press {<Home>}. The edit cursor should now be at the
first byte in the third line. This is buffer address 20. Look at the edit
window and note that is shows "20 FF-". Type {44}. The byte at address 20
has been changed to 44. Now practice moving about the screen with the arrow
keys; up, down, left and right. The <Home> and <End> keys move the edit
cursor to the first and last byte in the line. Press {<PgDn>}. Note that
the buffer addresses have shifted by 100. 100 hex is 256 decimal bytes.
Press {<PgUp>} to return to the previous screen. You've probably noticed
that there are actually two edit cursors. The main cursor which moves over
the hex data display and a smaller single character cursor which moves in
the display area at the far right. This is the ASCII display area which 
we'll cover later but you've probably noticed that each byte of data in
the HEX area has a corresponding location in the ASCII area. One more point
before we discuss additional fundamentals. Press {<Esc>}. This exits the
MODIFY command. Press {M}. Type {20<ENT>}. Note that you are now ready to
edit the byte at address 20. You can specify the address where you wish to
begin editing when you enter the MODIFY command. Press {<Esc>}.

At this point you should have a good understanding of the editor screen
organization. You know that each group of two characters represents one
byte of data. You know that each byte resides at a specific address. You
have used the MODIFY command to change a few bytes and used the arrow keys
to move the edit cursor around on the buffer screen. Our next exercise will
explain HEX, BINARY and DECIMAL numbers.

WHY IS EVERYTHING IN HEX?
Hex is short for hexidecimal or base 16. Humans use the decimal number system
which is known as base 10. Binary is base 2. The base indicates the number of
digits or symbols that make up the number system. Let's look at base 10.
Base 10 or the decimal number system has 10 digits. These are 0, 1, 2, 3, 4, 5,
 6, 7, 8, 9 and 0. Notice that there is no single symbol for the number ten.
We humans use two digits, 1 and 0 to represent the quantity ten (10). I'm sure
this is not news to you but what about computers? They use binary numbers
because all they understand is 1's and 0's. Since the binary number system
only has two digits, 1 and 0, how do you represent big numbers? The answer
is simple, you use a lot of 1's and 0's. Look at a big decimal number,
say 58,996,112. It takes eight individual digits to represent this number.
Each digit is a place holder. Remember this from grade school. The ones, tens,
hundreds, thousands, etc. When you reach nine there is no symbol for ten so
you carry to the next place and the nine becomes a 0. The same is true in
binary. The only difference is that when you add 1 to 1 and there is no
symbol for 2 you have to carry to the next place. Here's how it works in
binary. we'll count to three. Start with 0. Add 1 and you have 1.
Add 1 and you have 10. Not ten but one zero. Remember when you add 1 to 1
there is no 2 so you have to carry to the next place holder. Now add 1 more
and you have 11 (one one). Here's what we did. 0 plus 1 is 1; plus 1 is 2;
plus 1 is 3. Thats right, binary 11 (one one) is decimal 3. If we add 1 to
11 what do we get? 100 (one zero zero) which is decimal 4. Remember the place
holders in the decimal system are ones, tens, hundreds, thousands, etc. where
the number in each place represents that number times the place value.
Decimal 547 means 5 hundreds plus 4 tens plus 7 ones. Binary is the same
except the place holders aren't tens, hundreds, etc. They're much smaller.
In fact the only place holder that's common to all number systems is the ones
place. In binary the places are ones, twos, fours, eights, sixteens,
thirtytwos, etc. Let's go back to our binary 100 (decimal 4) and add 1.
We now have 101 (one zero one) which is decimal 5. Notice that in the fours
place we have one, in the twos place we have 0 and in the ones place we have 1.
Add them up. One 4 plus one 1 equals 5. Have you got it? Lets move on to
something bigger. Decimal 13. In binary we have eights, fours, twos and ones.
Each place can be either a 0 or a 1. To make 13 decimal we need 8 plus
4 plus 1. Our binary number would be 1101 (one one zero one). I hope you're 
catching on because we're heading for HEX. Imagine the decimal number 237.
In binary it looks like 11101101. You can see that as decimal numbers become
bigger, their binary counterparts are huge.

HEX TO THE RESCUE
Imagine one human trying to communicate with another with binary numbers.
In decimal you say 237. In binary you say one one one zero one one zero one.
Yuck. In hex you say ED. This is not ED like the name, it's the letters
E and D. Notice that it's even shorter than 237. Here's how it works.
Hex is base 16. This means that there are 16 symbols to represent the
numbers 0 through 15. The symbols are the same as decimal until we reach ten.
Since there is no symbol for ten, eleven, twelve, thirteen, fourteen and
fifteen in the decimal system, the hex system uses the letters A, B, C, D,
E and F. A is 10, B is 11, C is 12, D is 13, E is 14 and F is 15. Now let's
link our binary numbers to hex. Remember in our previous example we used
decimal 13. Decimal 13 was a binary 1101. 1101 is a convenient group of four
bits or half a byte. 1101 is 13 decimal which is D in hex. We just represented
a group of four bits with a single character. Do you see why hex is such a
popular way to express binary numbers? It's because it takes a single hex 
character to represent four bits. It takes two hex characters to represent
eight bits or one byte. It takes four hex characters to represent sixteen
bits or two bytes. You should now have a fundamental understanding of binary
and hex numbers and how they relate to decimal. To reinforce our previous
examples we'll use the editor. Press {C}{1}. The editor screen is now FF.
Press {M}{0}{<ENT>}.
Type {00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F}{<Esc>}.
You have now entered a sequence of increasing hex numbers beginning at
buffer address 0. Press {N}{B}. This sets the editor mode to binary.
Note that nothing appears to have changed. Press {M}{0}{<Ent>}. 
Notice that in the lower right corner of the screen the entry base has
changed to binary. Look at the edit window (upper left corner).
The address is 0, however the data is now eight binary bits, each 0.
The editor does not alter the entire display to reduce confusion.
It shows the current hex value in the selected number base and also allows
you to enter new values. Before we enter something new, press the right 
arrow key. As the edit cursor moves one byte right, the binary number in
the edit window changes. As you move the edit cursor right, watch the binary
number in the edit window increase. Move the edit cursor left with the 
left arrow key and watch the binary number decrease. This provides a visual
illustration of exactly how a binary number increases and how a hex number
is expressed in binary. Now let's enter a binary number. Use the arrow keys
to move the edit cursor until the address is 10 (beginning of the second line).
Type {11101101}. Notice what happened; the hex data changed from an FF
to an ED. Remember our previous example using ED? When the edit mode is set
to binary or any other number base the value is both displayed and entered
in that base. Let's change the base to decinal. Press {<Esc>}. Press {N}{D}.
Press {M}{0}{<Ent>}. Note the edit window now shows three zeros (because the
biggest decimal value eight bits can represent is 255 which takes three
places). Use the arrow keys again and move the edit cursor right and left
over the hex values and note the decimal equivalent numbers. Now move the
edit cursor to address 10 where the hex value is ED. Note the decmial number;
it's 237. You've now seen it in binary, hex and decimal. Lets enter a decimal
number. Move the edit cursor to address 11. Type {195}. Note the hex value of
C3 appears. Let's do one last number base before we move on to ASCII.
The last number base is OCTAL or BASE 8. Octal originated as a semi standard
with early minicomputers. With octal you use the digits 0 through 7 to
represent three binary digits. The problem with octal is that three is an odd 
number and you inevitably have a single bit left over. Press {<Esc>}.
Press {N}{O}. Press {M}{0}{<ENT>}. Use the arrow keys to move the edit
cursor right then left and note the changes. Especially note the change
from hex 07 to hex 08. Note the carry from 007 to 010. We're done with 
number bases. Press {<Esc>}. You can use the editor to display and edit
in any of the supported number bases which is helpful if you need to enter
data directly in binary or need to search for a decimal number.

ASCII AT LAST
Before we get into an excercise that uses ASCII, let's discuss why ASCII
exists at all. With the first computers, information was input using switches
and output was available on lights or numeric displays. The technology did not
exist to input or display alphanumeric (alphabet and numbers) characters.
As time passed, displays and keyboards were created which allowed computer
programmers and operators to more easily exchange information with a computer.
Each computer company created their own displays and keyboards--there was no
standard. This meant that a UNIVAC keyboard and display would not work and
could not be connected to an IBM computer. Also, the way information was
formatted was different for each machine and company. As time passed,
several companies collaborated to create a standard which would allow the
exchange of computer information between different machines and most
importantly, different displays. Many standards exist today but the one
of primary interest is ASCII (pronounced ASK-HE). ASCII stands for
American Standard Code for Information Interchange. ASCII codes are
defined bit arrangements which correspond to printed numbers and letters.
Every number, letter and punctuation symbol has a corresponding ASCII code.
Let's take, for example, the letter A. The ASCII code for the letter A is 41
hex or 01000001 binary. This means that no matter what computer, computer
terminal, display or keyboard you have or use. If that system receives a 41
hex code directed to it's display it will print an A. If you press the A key
on the keyboard, the system will send a 41 hex code. This standard allows
equipment manufactured by anyone to work with anyone elses products as long
as they adhere to the ASCII standard. This is a simplified definition and
there is more to ASCII than just characters. Also ASCII was originally defined
to use only seven bits but that's another story. Today eight bits are used and 
the upper bit is always 0 for letters, numbers and punctuation.

SOME ASCII STUFF
Press {C}{1}{N}{H}. Look at the smaller display window to the right of the
primary hex area. It is filled with periods (.). This area is the ASCII
display window. There is a period for every corresponding data byte in
the hex data area. Press {M}{0}{<ENT>}. Notice that there is a single edit
cursor at the first period. This corresponds to the first byte in the buffer.
Type {41}. Note the letter A appears in place of the first period. The system
displays a period if there is no corresponding ASCII character for the hex data
byte. Let's say you want to enter the word ANDROMEDA into the buffer but you
don't know the hex codes for each letter. Press {<TAB>}. Note that the entry
base changed to ASCII. Now type {NDROMEDA} to finish the word ANDROMEDA. Note
that as you type each letter the hex code is placed into the buffer and the
letter appears in the ASCII window. Press {<TAB>} and the entry base changes
back to hex. The TAB key switches to ASCII entry mode and back. You probably
noticed that you can also set ASCII entry mode using the Number Base (N)
command. Why would you want to use ASCII entry mode? Let's say you have an
eprom that contains a program which operates an instrument with a CRT display.
You want to change a word on the startup screen. All you have to do is read
the eprom contents into the buffer and use the Search command, which we'll
cover later, to locate the ASCII text. Once you know where the text is located
in the buffer you can use the Modify command to make any changes you wish.
This concludes our discussion of ASCII. At this point you should have a
good foundation in binary, hex and decimal numbers. You should understand
the concept of addresses and data plus you should have a good grasp of ASCII.
The next part of the tutorial is the last. It covers the remaining editor
commands. Press {Esc}.

BUFFER COMMANDS - ONE BY ONE
Before we get started with the individual buffer commands there are a few
ground rules. If you forget a command or how it is organized press the ? key.
A command summary screen is displayed. The editor gives you the ability to
perform very detailed operations on data contained in the buffer and in the
device installed in the socket. The editor was not designed to lead you
through an operation. We expect you to know what you want to do and instruct
the editor to do it. There is no undo. Each editor command is invoked with
a single key. As you've already experienced, M for modify, C for clear, etc.
Since the editor is specifically designed to work with data in the buffer and
the data must be specified by an address or addresses, the editor commands are
structured to accept direct entry of this information. There is no prompting
except where absolutely necessary.  When the editor is waiting for a command
the lower window displays ENTER EDITOR COMMAND ("?" FOR HELP/"ESC" TO EXIT).
To exit the editor press {<Esc>}.

MOVING THE DISPLAY WINDOW
Think of the data display area as a window which you move to view any 256 byte
area of the buffer. You may move the editor display window if the editor is not
currently executing a command. You may move the window by a single line, a page
(256 bytes), to the buffer end or to the buffer start. Press {<PgDn>}. Note
that the addresses shift forward by 100 each time the key is pressed.
Press {<PgUp>}.  Note that the addresses shift backward by 100. Press
the down arrow key. Note that the address ranges shift forward by 10.
Press the up arrow key to shift the addresses backward. Press {<PgDn>}
three times.  Press {<Home>}. Note that you have returned to the beginning
of the buffer. Press {<End>}. You have now moved to the end of the buffer.
Press {<Home>}. At the top of the buffer editor screen are three windows. 
The middle window shows you the very last address in the buffer. The right
window shows you the device size as a range. For the 28F256 the device size
ranges from 0 to 7FFF.

FILL
The fill command lets you fill any address or range of addresses with a hex
data constant. Press {C}{1}. Press {F}. Notice that when you pressed the
F key the command description appeared in the window. This occurs for all
editor commands. Now enter {70}{<SP>{7F}{<SP>{55}{<ENT>}.  Note that the FF's
on the line beginning at address 70 changed to 55. You filled the buffer
beginning with address 70 and ending with address 7F with the data 55.
The fill command lets you fill as little or a much of the buffer with any
data you choose.

TRANSFER
The transfer command lets you transfer or move blocks of data around in the
buffer. We'll transfer the line of 55's you filled between 70 and 7F to
address 0. Press {T}. Type {70}{<SP>{7F}{<SP>}{0}{<ENT>}. Note the the line
beginning at address 0 has become 55. You have transferred the contents buffer 
addresses 70 through 7F to buffer address 0. Note that you don't have to
specify a buffer ending address for the destination. The transfer command
lets you transfer as little or as much data to any location in the buffer as
you wish. You can also transfer data by as little as one location up or down.

For the next command exercises load the file TESTFILE.BIN into the buffer.
If you have forgotten how to do this, use command 4, option 1 from the main
screen. Once the file is loaded, select command 5 and proceed.

DISPLAY
The display command lets you display a single page of buffer data starting
at any address or a range of data between two buffer addresses. Let's display
a single page of buffer data at address 1000. Press {D}. Type {1000}{<ENT>}.
Note that the editor screen immediately displays the buffer data beginning at
address 1000.  You can move to any page address in the buffer in this manner.
Let's look at a larger block of data. Press {D}. Type {0<SP>FFF<ENT>}.
This instructs the editor to scroll through the data beginning at buffer
address 0 and ending at address FFF. The buffer data scrolls through the
window. If you wish to pause the data press <SP>. To continue the display
press <SP> again. The scrolling stops when the destination address is reached.

SEARCH
The search command lets you search the buffer for a string of hex bytes or
ASCII characters. You can search for a unique sequence of 1 to 16 hex bytes
or 1 to 32 ASCII characters. Let's search for hex bytes first. Press {<Home>}
to return to the beginning of the buffer. Press {S}. Notice to the right that
the system indicates that the entry base is HEX. You may change to ASCII by
pressing <TAB>. <TAB> is a toggle function which changes at each press.
Type {30<SP>30<SP>33<SP>30<ENT>}. The hex bytes must be separate by spaces.
We'll start the search at buffer address 0 so type {0<ENT>}. Look at the upper
left window. Note that the system found a match at address 3028. The edit
cursor is already located at that address and you may now choose your next
step. If you want to change the data at the match location you would press M.
To search for the next occurance of the string in the buffer you would press C.
To terminate the command and leave the display unaltered you would press E.
You may try the C option . Press {C}. The system scans the remaining data in
the buffer for another match. It finds none and displays "PATTERN NOT FOUND"
before returning to the buffer start. Now we'll search for the same data
pattern but as an ASCII string. Press {S}. Press {<TAB>}. Pressing <TAB>
changes the entry base to ASCII. Type {PAGE 0030<ENT>}. Type {0<ENT>}. Notice
that the result is the same. Press {M}. You have now entered the modify mode.
Press {<TAB>} to switch to ASCII entry. Type {PART}. Press {<Esc>}. You just
searched for PAGE 0030 and changed it to PART 0030. The search command is a 
powerful feature of the buffer editor which allows you to rapidly locate and
modify data. Note: Do not stop at this point or you will have to repeat the
search and changes exercise.

DIRECT DEVICE ACCESS
The EPROM+ editor is unique in that it allows you to directly work with the
device installed in the programming unit socket. Before we begin with these
commands exit the editor and install your EPROM in the programming unit.
Erase it using the Z command then reenter the editor with command 5. We'll 
first work with three commands with which you are already familiar from the
main command exercises. These three commands work in a manner similar to
their main counterparts but require you to specify absolute address
information.  The first is program device from buffer. Press {P}.
Type {0<ENT>}{7FFF<ENT>}. Press {P}. Your EPROM will program as it
did using main command 2. The difference is that the editor version of this 
command requires you to specify the buffer address range you wish to program
into your device. Now press {Esc}{C}{1} to clear the buffer. Press {R}.
Type {0<Ent>}. Press {Y}. The data from your EPROM is read into the buffer.
Press {<Esc>} to exit the editor. Use command 4, option 1 to load TESTFILE.BIN.
After the file is loaded use command 5 to enter the editor. Press {V}.
Type {0<ENT>}. Press {Y}. The system begins comparing the data in your EPROM
with the data in the buffer. It will find two errors. The errors are the
difference between the word "PAGE" which is in the buffer and the word "PART"
which is programmed into the eprom at the same addresses. Press {Y} to examine
the errors. After you view the first error press {C} to continue the error
search although none will be found. Press {<Esc>}. Although you could exit
the editor to perform any of these operations, it is very convenient to have
direct access to these commands.

INSPECT YOUR EPROM
The inspect command lets you examine the data in your eprom without actually
reading it into the buffer. Why would you want to do this? Let's assume you
have data in the buffer which was loaded from a file. You also have a device
installed in the programming unit socket. You would like to inspect the device 
without loading it into the buffer which would destroy the data from your file.
Press {I}. Type {0<ENT>}. Notice the upper middle window changes to DEVICE
CONTENTS. The editor screen now displays the data from the eprom, not the data
in the buffer. Press {<Esc>}. Now let's inspect and compare. Press {I}.
Type {3000<SP>3000<ENT>}. The system again displays the eprom contents,
however it compares the data in the eprom to the data in the buffer.
Any differences are shown in reverse video. The reverse video means that the
data at that address in the buffer does not match the corresponding address
in the part. Use the inspect command whenever you need a quick view of the
data within the chip or when you wish to perform a quick view and compare.

WRITE DATA INTO YOUR EPROM
The write command lets you write data from anywhere in the buffer to anywhere
in the eprom. This is different from the program command which always programs
data from the buffer into the first address of the eprom. Let's try this out.
Before we begin, erase your eprom. I assume that by now you can do this 
without instructions. After your eprom is erased, load TESTFILE.BIN into the
buffer. Press {W}. Type {80<SP>8F<SP>20<ENT>}. The system will quickly program
the data into the eprom and verify that it programmed correctly. Here's what
you instructed the system to do. Write data into the device beginning at
address 80 and ending at address 8F starting at buffer address 20. In other
words we took the data from buffer addresses 20 through 2F and programmed it
into the eprom beginning at device address 80. This command might be a bit
confusing because you specify the starting and ending addresses of the device 
first and then the buffer address where the data is to begin. This is done 
because the device has a fixed address range which always begins at 0 while
the buffer has a large address range which usually exceeds the device size.
Now let's view what you just programmed into the eprom with the inspect
command. Press {I}. Type {0<ENT>}. You see on the display all FF except
one line of data beginning at device address 80 and ending at 8F. Notice in
the ASCII display the word "ANDROMEDA" has now been relocated from it's
position which was 20 through 2F, to 80 through 8F in the eprom. The write
command let's you take any block of data from the buffer and place it anywhere
in the device. One caveot, although the write command checks to be sure that
the data programmed correctly, it does not check that the data area in the 
EPROM is erased before the write operation occurs. This is because you may
wish to overwrite existing data. Don't use the write command in place of the
program command as it will not be as fast. The write command is intended only
as a tool for small, precise programming changes. Press {<Esc>}.

PROGRAM A SINGLE BYTE
This is the last command which lets you directly affect the data in the device.
This is the single byte program command. Press {E}. Type {69<ENT>}. Notice
that the edit window shows that buffer address 69 contains a 46.
Press{<Ins><Ins><Ins><Ins>}. Note that each time you press Insert the data at
the address changes to reverse video. This indicates that the data at that
address has been programmed into the corresponding address of the device.
Each time you press the Insert key a single byte is programmed. Let's look at
what you did. Press {<Esc>}.  Press {I}. Type {0<ENT>}. Notice that the word
"FILE" has now been programmed into your eprom at the same address as it exists
in the buffer. Press {<Esc>}.  This command is intended for extremely precise
byte edit operations. There are two restrictions for this command. The first
is that the device addresses and the buffer addresses are an exact match and
always begin at 0. This means that buffer address 0 will exactly correspond
to device address 0. The second is that the system does not check  for proper
programming after the operation is complete. Use the inspect command to view
the result of any changes you make.

A FEW MORE COMMANDS
There are a few more commands which you may find useful. The first is the
buffer checksum command. This command allows you to calculate a checksum
over any address range in the buffer. Let's perform a checksum over the
displayed area of the buffer. Press {K}. Type {0<SP>FF<ENT>}. The system 
calculates the checksum over the buffer range beginning at address 0 and
ending at address FF. The result is SUM=4B65, ONES COMP=B49A, TWOS COMP=B49B.
You can use this command over any buffer range from a few bytes to the entire
buffer. Press {<Esc>}. The next command is logical operations. This command
allows you to AND, OR or EXCLUSIVE OR a buffer byte or range with a fixed byte
constant. Logical operators allow you to clear or set individual or
combinations of bits in a byte. Let's set the upper four bits or all the bytes
between address 0 and FF to 0. Watch how this works. Press {L}.
Type {0<SP>FF<SP>0F<ENT>}. Press {A}. Notice that the upper 4 bits
(first character) in all the bytes changed to 0.  Now let's change the upper 4
bits from a 0 to a 3. Press {0<SP>FF<SP>30<ENT>}. Press {O}. I'm sure you've
caught on to the command structure. Like other editor commands, you specify
the address range over which to execute the operation followed by the data 
constant. The "A"nd operator forces any bits which are not 1 to a 0 state. 
The "O"r operator forces any bits which are not  1 to a 1 state. Although
we're not going to do an exclusive or operation, this operator performa a
single bit add with no carry. In other words a 1 added to a 1 will equal 0.

A 0 added to a 0 will equal 0. A 1 added to a 0 will equal a 1. You can try
an exclusive or operator on your own. Here's a hint. If you need to invert
the bits in a byte, use the exclusive or operator with FF as the data constant.

HEX ARITHMETIC
If you need to perform an arithmetic calculation such as add, subtract,
multiply or divide, the arithmetic command provides a simple 16 bit integer
calculator. Let's add the numbers C955 and 1BB7. Press {A}.
Type {C955<SP>1BB7<ENT>}. Press {+}. The system adds the numbers and displays
the result, 00E50C. Let's subtract the numbers. Press {A}.
Type {C955<SP>1BB7<ENT>}. Press {-}. The system subtracts the second number
from the first and displays the result, AD9E. You may also multiply and divide.
The division result is shown as a quotent with remainder.

BYTE SWAP
The byte swap command swaps the odd and even bytes in the entire buffer. Load
TESTFILE.BIN and press {B}. Press {Y}. Note that the bytes swap position. Why
would you want to do this? There are times when the data from a file or a chip
is backwards from the organization you require. The byte swap command swaps
adjacent (even to odd and odd to even) bytes. This provides a quick and
convenient way to rearrange the buffer data into the format you require.
Press {B}{Y} to return the buffer to it's original format. 

WORD MODE
The last editor command we'll discuss changes the data entry and display format
from byte to word. Before we continue, let's be sure you understand the
difference between bytes and words. In simplist terms a byte is 8 bits

and a word is 16 bits. A word is simply two bytes treated as a single quantity.
Let's quickly review. A byte value is two hex digits like 55. A word value is
four hex digits like AA55. Load TESTFILE.BIN. Press {O}. Notice that the entire
data arrangement changes and in the edit window the mode is now WORD. Each two
character byte is now replaced by a four character word. Think of each word
value as being composed of two bytes; a high byte (left) and a low byte
(right). There's one item of which you must be aware when dealing with
a word value. The low byte is always on the right with the high byte on
the left. This is different from byte mode where the bytes are in sequential
order. Also notice that the address values are divided by two. This is because
there are half as many words per line as bytes. In other words
(no pun intended) each word address represents two bytes. Let's look at how
this works. Press {M}. Type {0<ENT>}. Notice that the edit cursor is positioned
over the low byte in first word. Also notice in the edit window the address
is 0L. The "L" indicates that the edit cursor is positioned over the low byte.
Press the right arrow key. Notice that the edit cursor moves to the high byte
of the word and the edit window address is now 0H. Press the right arrow key
several times and notice that edit cursor moves from low byte to high byte and
then to the next word. Also notice that the ASCII display area does not change.
This is because in word mode, text data is still stored in sequence. If the
ASCII area changed to word format, you would not be able to easily find text
in which you have interest. Press {<Esc>}.

DIFFERENCES BETWEEN BYTE AND WORD FORMAT
The primary difference between byte and word mode is that in word mode address
and data represent word values instead of byte values. The only exception to
this rule is the M command which still requires that you enter high and low
byte values at each word address. Each command described previously, such 
as fill and transfer expects you to enter word values. Lets try a word mode
fill. Press {F}. Type {0<SP>7F<SP>55<ENT>}. Notice that the word values
changed to 0055. This is because the upper byte was assumed to be 00 since
it was not specified in the command. Let's do the fill again except with a 
complete word value. Press {F}. Type {0<SP>7F<SP>AA55<ENT>}. Notice that now
the word value AA55 fills all locations on the screen. This shows the power
of word mode. If word mode was not available it would be extremely difficult
to fill a large group of buffer locations with alternate bytes of data.

Why have a word mode? There are many microprocessor systems which are larger
than 8 bits. One popular group currently in use is the Microchip PIC family.
The PIC family of microcontrollers have instruction word lengths of 12, 14
and 16 bits. It is extremely difficult to visually deal with the native device
data in byte mode. It is much easier to set the editor to word mode and view
the data in it's native arrangement. There are also 16 bit eproms such as the
27C1024 which actually store the data in word format. The word mode setting in
the editor makes this possible.

This concludes the EPROM+ tutorial. With the completion of these exercises,
you have been exposed to the operation of each system and editor command.
You now have a good foundation which will allow you to obtain the highest
level of performance from the many capabilities of your system.

