# Ee ey dee aie Bis ae ie

SRE Sacaae Se a

Bie ees peas

Sa SRE

ses 23

ag _.

3 By pauaaiet 7

7 co

ee es

Re coe

he fee ays

s t BS

are ce ace

estes § Bae as

. : aL

eats Bs ox seats ee Cs BRekoRaRs e Ate 4 bt. | of : : . og . oo skal eapaeaeaene fy « ® : carga “8 ¥ SS SS | RS : ee : :

See

3 ee

RENIN“ Raa

FITTING THE BILL We examine a | number of products currently on the market 8? that are billed as ‘robots’ and see how well they conform to our definition of the term

A TOUCH OF CLASS The Touchmaster is a new graphics tablet that is designed to work 83 with most of the popular home machines.

We see how it compares with its rivals

Bs = sai

EDUCATED GUESS We conclude our look at TK! Solver by looking at its ability to solve equations from incomplete information through a series of ‘guesses’

WHO D ND IT? Using the example ofa

murder mystery in which a list of suspects is 83? drawn up and analysed, we continue to examine the use of list processing in LOGO

RARER

NFORMATION STORAGE AND — RETRIEVAL TO INKJETPRINTERA 8 weekly glossary of computing terms

PROGRAMMING PROJECTS

TAKING ORDERS Now that we have discussed methods of moving around the 876 adventure world, we can look at how the

program analyses instructions from the player

00000000

TSS BONES POET PTET Se ORO RO NETS

YTE THE DUST Our debugger program is now complete and this instalment also 8 concludes our series on 6809 machine code

OUTBOARD MOTOR We look at the

working principles of the stepper motors that B35 will be used to power the robot we are

building and construct the board to hold the

motor and accompanying parts

REFERENCE CARD We begin to list INSIDE extracts from the 6502 programmers’ BACK reference card | COVER

COVER PHOTOGRAPHY BY CHRIS STEVENS ROBOTS COURTESY OF ROBOTICS WORKSHOP

FITTING THE BILL

As we continue our series on the topic of robotics, we examine some of the products sold commercially under the name ‘robot’ to see if they fill the role expected of them, and if they fit our carefully constructed definition of the term.

Up to this point in the Robotics series, we have dealt primarily with theoretical considerations of robot design and operation. In practice, many of the concepts discussed have not _ been implemented, or are restricted by a lack of funding, intricate mechanical parts, and/or intelligent software. Existing robots, whether they are intended for home or industrial use, tend to fall short of what we have come to expect of robots over the years. Sensors exist to make a robot see, hear, or feel, but as yet the sensations the robot experiences have no meaning for it, and cannot be synthesised to stimulate the robot to original, non- programmed behaviour. Robbie the Robot and his other fictional counterparts are still a long way from reality.

Nevertheless, many products are now being

Spot The Robot

sold under the name ‘robot’. These range from

small toys for under £1 to vastly expensive R2D2

lookalikes and industrial robots. After examining the components of robot design and theory for several instalments, we must now consider what

constitutes a true robot. We must not be too

demanding, but we should be able to take what we know and apply it in a workable definition.

The first consideration, and one that eliminates many of the lower-priced ‘robot’ products, is movement: can the robot move about a space by itself? We cannot expect the robot to program itself, or to set a course of action without human guidance, but we can expect a robot, once set in motion, to be able to operate independently of continuous human control. Without this freedom of movement, an object cannot be considered a robot. : 7 |

Having passed the test of movement, our robot candidate must now be evaluated on the basis of

how the movement is effected. A small toy car can

be given a motor and batteries that keep it moving

in a straight line. Add bumpers to it, and the car

can turn away from obstacles such as walls and tables. Give the car a slightly unusual centre of

Our Robot

Powered and controlled from its parent computer, the robot is equipped with touch- and light- . Sensitive sensors

Big Trak

LOGO-like distance and direction instructions can be programmed into this microprocessor-driven device through its keyboard

a =e =)

Bumper Car

This battery-powered toy will

run ina straight line until it hits

an object, in which case it will turn clockwise 90° and continue

STEVE CROSS

Amazing Tracks

The three devices are attempting to run a maze: the toy car simply blunders from wall to wall, Big Trak follows its human operator’s programmed instructions for running the maze, while our robot learns the maze through the interaction of its software and sensors. We can be sure that the robot will solve the maze eventually, no

matter what happens; Big Trak 3

will follow its program, so may solve the maze if the operator's directions are correct; the toy car could solve only ‘right- handed’ mazes, and then only by chance. !

When the car collides with Big Trak, the car is unaffected since its behaviour is purposeless; Big Trak, however, is diverted 90° off its course (shown in green) but continues to turn and travel as if it were still on track (Shown in red). Both devices react unintelligently to this unforeseen event where the © robot would treat it as just one more aspect of an unpredictable environment

THE HOME COMPUTER ADVANCED COURSE 821

9009000 oO

\ e)

ROBOTICS, APPLICATION

EDUCATED GUESS —

examination 0 TK!Solver an equation processing program for the Apple Il, IBM PC and compatibles, and the ACT Apricot — with a closer look i i ilities.

As we explained in

spreadsheet series (see page 804), TK!Solver is a

‘next generation’ software package that takes the concept of the spreadsheet into the realm of higher mathematics and engineering. We have already shown that TK!Solver lets the user define variables with names and use these in complex mathematical equations. In this instalment, the last of our spreadsheet series, we look in detail at TK!’s unusual ability to iterate. This is a method where the program can solve for a variable by guessing at it. Ordinarily, when working with equations, one can determine the values of all the variables if enough information is given from the

outset. The program simply reduces the problem |

to a series of calculations. For example: A? + B = 2C0S Y

can easily be solved for any of the three variables if

the other two values are known. Faced with this

equation — and given values for A and B — TK!s

Direct calculations and output a value for Y.

- But there are occasions when the determination

_ ofavalue is not straightforward. One such case is a

redundant equation, which defines a variable in terms of itself. For example, consider:

D=(A+B)/(2*D)

within a model where A is the only known value. Other problems can occur as the result of an incomplete model, or a model with many interdependent variables and a limited amount of data. The concept of iteration is a difficult one, so

let’s look at a more practical example of iteration. — Let’s reconsider the car journey model created —

in the last part and add a few details to make it more applicable. As you will recall, the previous model was built around five values: distance, time, speed, fuel and mileage. It could calculate mileage, given speed and fuel consumption; distance from speed and time; and several other simple variations. What if we now want to determine how fast we should travel in order to complete a trip within a given budget?

To begin with, we must add several factors to our model. For instance, the model must take into account the power output of the vehicle, the internal friction of the engine and wind resistance,

824 THE HOME COMPUTER ADVANCED COURSE |

Solver would perform the required:

rae

all of which will have an effect on the vehicle’s mileage and speed. (We will assume that internal friction is constant.) We must also have an upper

boundary for our budget, and the cost of the fuel

being consumed. | 7

We'll begin building the actual model by entering these equations in the Rule sheet, one equation to a line. These equations are read automatically into the Variable sheet: _

Building Equations

Because there are several variables, the screen is too small to hold all the information. To see all the variables displayed, we can show the Variable sheet in a window by itself. We do this by pressing the semi-colon key (;) to move the cursor into the variable window, and then type in W1. Now all the variables can be seen and we can begin entering values for them. _

DIRECT SOLVING

The model can be solved directly, if enough |

information is given at the start. For instance, enter the following values in the INPUT column:

Input Values For Direct Solver

IAN McKINNELL

Then press ! to perform the calculation. TK! displays the message Direct Solver, and the unknown values appear in the OUTPUT column, as shown: ;

Direct Solver Results

This gives us a nice breakdown of all the information we want. But what if we want to use this model to solve a problem with less information given at the outset? Let’s consider a calculation where we have a maximum budget of £50 to spend on fuel for a 1,000 mile trip. We know the price of fuel (say £1.75 per gallon) so we can easily determine how much we can spend per mile. It might be more difficult, however, to determine what speed we need to travel in order to achieve the mileage needed to complete the trip within our budget.

We begin by blanking the values already entered. We do this by typing RVY (for Reset Variables Yes). Then we type in the information that we know: 1000 for distance, 50 for cost, and 1.75 for price. We use a value of 1/3 for internal friction (which TK! evaluates to 0.333333) and 0.0000095 for wind resistance. Press ! to calculate and the following values appear:

Incomplete Model

Note that no values have been generated for speed, time or power — and speed is the specific value we need. If we shift the display from the Variable sheet to the Rule sheet, we will see that three of our equations remain unsatisfied (which is indicated by the * in the Status column):

Unsatisfied Equations

ITERATIVE SOLVER

Since we cannot solve the model using the Direct

Solver, we must try the Iterative Solver. This takes a starting value, input as a guess, and fits it into the equation. If the value is not correct, TK!Solver uses a series of successive approximations (like the game of ‘higher’ and ‘lower’) to pinpoint the exact value. |

The first thing we do is take the mileage value generated previously and move it into the Input column to give TK! one extra value to start with. We do this by typing | in the Status column next to mileage on the Variable sheet. Then we estimate a value for speed — say 50 — enter that number in the Input column, type G for guess in the Status column and press ! to calculate. TK! displays Iterative Solver at the top of the screen and counts off each approximation. On the fourth attempt, TK! arrives at the correct value for speed, time and power, as shown: |

Hterated Values

According to TK!Solver, an average speed of just over 47 miles per hour is needed to complete the trip within our budget. The closer a guess is to the actual value, the sooner TK! finds a solution. TK!Solver is available from Practicorp for the Apple II, IBM PC and compatible machines, and the ACT Apricot, for £195. Software Arts also publishes ‘Solver Packs’ at £95 each with predesigned models for specific applications.

THE HOME COMPUTER ADVANCED COURSE 825

~ TAKING ORDERS

Up to this point in our adventure game programming project, we have discussed methods of map making, formatting output and moving around the adventure world. In this instalment, we show how the program analyses and obeys instructions given to it by the player.

826 THE HOME COMPUTER ADVANCED COURSE

Adventures are usually constructed so that the »

player can move from location to location, picking up and dropping objects along the way. A set of commands allows the player to perform these simple tasks. The commands we have used are:

Variations on these may also be available, such as MOVE instead of GO, or GET instead of TAKE. Part of the fun of playing an adventure game is to determine what words the game will accept. For example, a player might try the command SWIM when in a dry location. If the program responds by telling the player that he cannot swim here, then the player could reasonably assume that there are locations where swimming is allowed. (Alternatively, the programmer might just want the player to think that!)

The number of commands accepted by a game varies according to the complexity of the game and the amount of effort the programmer has made to cover every eventuality. The most important thing for the designer to do is to make sure the program does not crash if a player tries to enter a command that is not catered for. A failsafe routine that prints ‘I don’t understand’ may be all that’s required, bearing in mind that some flexibility should be added so that players can enter commands in different ways. For example, it would be annoying for a program that accepts the command TAKE LAMP to respond to,the command TAKE THE LAMP with ‘I don’t understand’. Adding flexibility will be discussed at greater length later. For the moment, we need to look at the type of instructions that

might be given during the game, and devise a

routine that will break these down into a form that can be easily interpreted.

COMMAND SPLITTING

No matter what the instruction is, it is very likely that it will be phrased in the imperative — such as, GO SOUTH TOWARDS THE RIVER or KILL THE ALIEN. The advantage of this sentence structure is that it is easy to break down: the verb always comes as the first word in the sentence, the object of the verb follows this, and finally there may be some form of qualification of the action. A first stage in the analysis of a command is to separate the verb from

the rest of the sentence. This task can be easily achieved by scanning through the sentence one character at a time, using MIDS, until a space is found. The part of the sentence that lies to the left of the space is the verb, and can be assigned to the variable VBS. The part of the sentence to the right can be assigned to a second variable, NNS. This subroutine is used in Haunted Forest to split the instruction assigned to the variable ISS:

256@ REM *xx**x SPLIT COMMAND S/R *2%«x%

25190 IF ISS="LIST”" OR IS%="END" THEN ¥VBS=1S$!:F =12RETURN P5515 IF IS#="LOOK" THEN V¥VBS=IS#$:iF=1:5RETURN

2520 F=8

P3538 LS=LENCISS>

. 2340 FOR C=i TO LS

25580 AS=MIDSCIS$,C,13

e568 IF AS<>" " THEN 2599

2578 VBS=LEFTSC(IS$,C-1):5F=1

2588 NNS=RIGHT#(IS$,LS-C)IC=LS

25969 NEXT C

e6baa :

261@ IF F=i1 THEN RETURN

2620 PRINT:PRINT"I NEED AT LEAST TWO WORDS”

2630 RETURN

Before the routine attempts to split up the sentence, it first checks to make sure that the command is not one of the three possible single- word instructions — that is, LIST, LOOK or END. If it is a single-word command, then the complete instruction is assigned to VBS, and the routine is exited. If the command is not one of these, then the routine enters a FOR...NEXT loop and begins to scan for the first space. Two techniques used within this loop need special mention. Both relate to the fact that it is extremely bad programming style to perform a conditional jump out of a FOR...NEXT loop without passing through the NEXT statement. Instead, to signal the fact that some condition has been met — in this particular case, that a space has been found — a flag, F, is set to one. Secondly, when the first space has been found, it is a waste of time to continue scanning through the rest of the sentence.

The loop can be neatly terminated at this point by setting the loop counter, C, to its upper limit, LC. Consequently, when the program again reaches NEXT, it will pass on to the following instruction, rather than loop back to the FOR statement. Once the ioop has been correctly terminated, then the status of the flag, F, can be tested. A flag value of one indicates that the sentence consists of more than one word, and ail that remains to do at this stage 1s to return to the main loop. If the flag is not one, then the command has only one word and is not one of the single-word commands tested for earlier. In this case, a message stating that two words are required is printed before returning for another command. |

NORMAL COMMANDS

For the main part of the program, the player will simply move from location to location and pick up or drop objects that may be found. Therefore, for the majority of locations, the commands GO, TAKE, DROP, LIST, LOOK, END — and their variants — are sufficient to allow the player to do this. Only in unusual circumstances will the player wish to use other more specialised commands. For example, there is little point in using the command KILL if

there is nothing present to kill. We can, however, devise a program structure where, on the majority of occasions, only the six commands associated

- with movement and objects are tested for. When

the player enters a new location, the program can test to see if it is one that has been designated ‘special’ in some way. If this is the case, then any new command requirements can be dealt with bya specific command subroutine for that particular location. Therefore, the main calling loop to our program should do the following:

1) Describe the location and list the exits.

2) Determine whether the location is ‘special’. 3) Ask for a command and, if the location is not special, scan the list of normal commands.

There must also be a facility in the main loop to distinguish between a command that causes a — move to a new location and one that does not. In the first case, the loop needs to go back to the beginning of the loop to describe the new location | and decide whether or not it is special.-In the second case, it is necessary only to loop back to ask for a new command. The simplest way to implement this is to use a ‘move flag’, MF, which is normally set to zero. If a command involves movement then this flag is set to one. The status of MF can be tested at the end of the main loop and the appropriate jump made. Add the following lines to Haunted Forest:

27@ GOSUBESOO=REM SPLIT INSTRUCTION

275 IF F=0 THEN 260:REM INVALID INSTRUCTION, 2386 GOSUB3S@08:REM NORMAL COMMANDS

296 IF VF=@ THENPRINT:PRINT"I DONT UNDERSTAND” 30@ IF MF=1 THEN 246:REM NEW LOCATION

3160 IF MF=-@ THEN 266:REM NEW INSTRUCTION

3000 REM *x** NORMAL COMMANDS S/R «**%

3010 VF=8:REM VERB FLAG

3020 IF VBS="GO" OR VBS="MOVE" THENVF=1:!GOSUB3500

3039 IF VB$="TAKE" OR VBS="PICK"THEN VF=1:GOSUB3790

3040 IF VBS="DROP" OR VBS="PUT"THEN VF=1:GOSUB3900

3050 IF VB$="LIST" OR VBS="INVENTORY"THEN VF=1:G0S UB4 100

3055 IF VB$="LOOK" THEN VF=1:MF=1:RETURN

3068 IF VB$="END" OR VBS="FINISH" THEN VF=1:GOSUB4 178 2

3078 RETURN |

In the first routine, another flag, VF, is used to indicate whether or not the verb has been understood and obeyed. Only when the verb has

been isolated is VF set.-to one. We can insert a failsafe ‘I don’t understand’ statement in the main

loop by testing the status of VF. If VF remains zero

then the verb in the command has not been recognised by the analysis routine, and the statement is displayed.

In the next instalment of the project, we will deal with subroutines for picking up, dropping and listing objects. For now, we can add a short END command subroutine to our group of normal commands:

4176 REM x*xex*x END GAME SYR **%x

4180 PRINT:PRINT"ARE YOU SURE (Y/N) 7"

4196 GET ASI IF AS<C>"Y" AND AS<>"N" THEN 4198 $2698 IF AS="N" THEN RETURN

94216 END

The LOOK command is also straightforward. To redescribe the current position, we simply need to set the ‘move flag’, MF, to one and return to the main program loop. Setting MF will cause the main

-THE HOME COMPUTER ADVANCED COURSE 827

RETURN

THEN NN@=hie! 1=LN

THEN NNS=LH: IT =LN

C=1

THEN NEXT I +1 ="EAST" ="WEST"

LEN (NN?) # C=

We Sap he

Cd: CR WS OR LE

ion words sought until a match is

1 TQ LN I Cc

="NORTH"

= = F *

direct = "SOUTH"

NN#+"

MIDS CNN&

645 FOR I 3656 IF MIDS CNNS

3630 REM *x*x** SEARCH FOR OIRECTION S/R ERE 3655 WS

the four found 3646 NNS& 36660 IF WS 3665 IF We 3678 NEXT I 3675 RETURN

g ts. t

ca S is no ocati if, ions

changed by the LOOK command, the same! Th the player has performed a series of

will

its exi e on after , the has

act

g, thus d on of the current location

iable

command is useful

1S ADDING FLEXIBILITY

cribe a location an

es that des the value of the location v.

routin al descripti

be describ moved off the screen

origin

program to loop back to the be

the As

ooo00000 0

90000000 is

ect we developed a

e proj

To add th e we need

instalment of th

In the last

ew routine to the imply to add the

isn

routin

movement rou

the player

different forms of the

g movement commands,

issuin

When

ent

ORTH following line

same movem

may type in

ins

, MOVEN

GO NORTH

ample

on. For ex

tructi

a D = Sos oO ~~ ) O& OW ry ase o : OR rf peweed n- zy er o Ltd - £€x5 » Pas « 20O¢ no eae oe eo fa SO tS — ce e to o Sa ie = oe w bo © & f #Ss to 3 8 © ean iD) it) NM. 2 2 ae o £20 a esa B hes in Awe Vs a aS ¢") 2 8°32 oor oH = 3 pEeuS Se Bp Soeas & on =o G a» A m= SELLE 4 eae CS Oom'™ 6 om Og bad Send q SBaes aoe on SD Cpe 5s OobEeES a & o) 3 = a2) of 60. ie ie Bae > 5 ZeGas © ° = Shee Fagan? bon Bogs ep 0 O Zea § SS hee

OH og BCDO DOW Sepgecagse SO, 5 ¢ Sues Se a25 Ra 05 shOos S2EE Se aea* 3 ho ZBESoenwERUH= oO Sige. gs S2P85 2595 5 oO sSa2o- mae Oy hos o B Oe a op OP 4S e&O 8 asses & 55 = 9 8 - BZ Soh sey 8s wSegseeaes Beene an © @ DY & Men) roe) bed Bey > AS 4?) ae we 2 on ooger= ae ee oe OO. oOG5 3 0 2 zs ce & 5 See bE LD SsReea0naqgzc OE Of omg ORS 29 SELES LS6SZsSS Onna soo yo a “meee ss oa DO O'S oR? RS. ar > = 2S aD) ou N oD Sh 3 Oo eS ga or eR. e BSR et ES a 2 cSSU EE F]asP ro gd os SHEER Y Spesa” ’ se Sm ag k US ES -vses Syeeagros ) Ro S Ssvosevts eaegag” : 23 hg oe FE Sore SES > N 5) * ai end Peo bees Roe Sis d 0 D) = Fp) ove) EEERoMvE =S=Sov gE os ates B= -=yc RPeaeees 22

ed as N for NORTH.

would be accept

828 THE HOME COMPUTER ADVANCED COURSE

INFORMATION STORAGE AND RETRIEVAL

Information storage and retrieval’ is the term used for the accessing and retrieval of information from a magnetic medium such as disk, tape or — in older systems — cards or punched tape. This information may be in the form of files, programs, data or graphics. It is necessary to use a storage medium that will not only retain the information when the power is switched off, but also allow the computer to read the information back in at some other time. This means that a computer must have, or be attached to, an interface that can read and write the data. Thus information storage and retrieval has come to mean not only the process of reading and writing information, but also the

techniques involved in such a process.

INFORMATION TECHNOLOGY

In one sense, information technology has been around for thousands of years: hieroglyphics, the abacus, the quill pen and the printing press are all examples. In the last decade or so, following the development of microelectronics and_ the subsequent dramatic fall in the price of such circuitry, information technology (IT) has come to mean the electronic storage, transmission and processing of information — specifically with reference to computers, video and pager es As such, IT has already had a profound effect on much of the world’s population, and most major organisations are now dependent on computers. An enormous amount of effort and resources is currently being put into information technology. The world now depends for its communications on satellites, such as COMSAT, while other satellites constantly monitor every inch of the world’s surface.

INFORMATION THEORY

Information theory (developed by Claude Shannon at Bell Laboratories, New Jersey, in 1948) is the area of computing that investigates the transmission of data. It involves the examination of newly-arrived data and whether it tells us something new — that is, the extent to which it reduces the uncertaintyin the information system. Thus, information theory consists of the study of the nature of the information and its speed of arrival. In its simplest form, this restricts information theory to the rate at which new information arrives, and from which channel or source.

However, in a wider sense, information theory can include such areas as coding theory. This discipline covers the translation of data from one form to another, and how this can be accomplished efficiently without any loss of the information being transmitted.

INITIALISATION

Primarily, initialisation is the process performed by the computer’s ROM-based operating system when the machine is switched on. This involves

default values being placed in the registers and various addresses in memory. Typically, during initialisation, a microcomputer will set the stack pointer, clear the decimal mode and initialise the various input/output devices. This initialisation will also set the top and bottom of memory pointers and the zero page. Finally, initialisation includes the setting up of the initial screen display and the screen editor variables.

Initialisation has a second meaning: the

formatting of disks. This takes the form of writing

the track that will contain the disk directory. The information written on this track is the disk’s title, the block availability map (BAM) and a list of markers for each track on the disk.

Initialisation can also be performed by programmer. If a program is to be properly structured, variables should have initial values assigned to them at the beginning of a program. This is often termed the ‘initialisation procedure:

INK JET PRINTER

An ink jet printer forms characters by squirting droplets of ink from a nozzle at the piece of paper.

Although these printers were developed in the

1960s, it was not until the mid-1970s that their use became widespread.

There are two types of ink jet printer. The pulsed jet printer consists of either one or a number of nozzles, which fire several droplets to produce a single dot on the paper. By arranging these dots in patterns, characters can be built up — in much the same way as a dot matrix printer forms its type. If a number of nozzles are fitted to the print head, then the user has the possibilty of multicolour or higher resolution printing.

The other type of ink jet printer is known as the continuous stream printer. As its name suggests, this printer shoots a continuous jet of ink at the paper. The droplets in the stream are electrically charged as they leave the nozzle, and then pass between charged electrodes, which alter the direction of the ink stream. The droplets of ink are directed to a precise position, and the character is drawn in much the same way as a pen stroke.

STEVECROSS

A Drop In Quality

Ink is fired at the paper through a nozzle that breaks the stream into separate droplets. These are electrically charged, which enables the metal deflector plates to direct them into character patterns on the paper — the electron beam ina cathode ray tube is moved around the screen in exactly the same way

THE HOME COMPUTER ADVANCED COURSE 829

IAN McKINNELL |

~ ATOUCH OF CLASS —

} The Touchmaster Pad

The sheet provided with the software simply slots into the drawing area. By pressing the appropriate command on the right-hand side of the overlay and moving the pencil, stylus or finger to the drawing area the command will be executed on the screen

830 THE HOME COMPUTER ADVANCED COURSE

as aids in the construction of graphics displays. The Touchmaster graphics tablet is unique in that it may be used with most of today’s popular home computers and, so the manufacturer claims, can also be used as a simplified replacement keyboard.

Today’s best-selling computers all support high- resolution graphics displays. However, unless

ready-written graphics software is available, much

time and effort is required to create such displays

and many features are not fully utilised. A ‘sketch’

program is not sufficient because the user will often wish to copy an existing image into the computer instead of simply drawing freehand. Several digitisers have been marketed for this purpose, but these have mostly been designed for use with specific machines, such as the BBC Micro or ZX Spectrum. The Touchmaster graphics

Many different devices have been marketed |

tablet is designed to work with a wide range of home machines (some of which will require a suitable interface or cable). This device is also being promoted as a replacement keyboard, but the simplicity of its design means that such use is restricted to selection between a number of menu options or for simple.games control. A computer

keyboard 1s still required for data entry, as well as

for loading the Touchmaster software itself.

The Touchmaster is fitted in a neat grey case measuring 350 by 330 by 35mm. The back of this is slightly raised, forming a convenient angle for drawing. A plug-in transformer is supplied, with a single red LED indicating when power is on; however, no on/off switch is fitted. To allow the tablet to be used with a wide range of home machines, both serial and parallel interface sockets are fitted to the rear panel, together with a socket — not mentioned in the manuals — for a foot switch. In fact, the manuals are barely adequate: the hardware manual gives instructions on the connection of the tablet and provides a number of simple BAsic programs for reading co- ordinates, but is insufficiently detailed.

The tablet relies on the membrane technology that was developed on the ZX81 and Spectrum keyboards, and provides a 256 by 256 pixel resolution. The upper layer is separated from the lower resistive film by an insulating mesh, and pressure on the upper layer forces it to make contact with the film. The tablet contains a microprocessor that scans the top film in one direction while scanning the lower layer in another, and the co-ordinate of the ‘contact point’ is then sent over both serial and parallel interfaces. The serial interface is used to connect the tablet to the BBC Micro, while the parallel interface is required for use with the Commodore 64, Vic-20, Spectrum and Dragon. The ‘Touchmaster’s resolution is less than that provided by many hi-res screen displays, so BBC Micro owners, for example, will be unable to resolve to a single pixel in Mode 0.

MULTIPAINT PROGRAM

A drawing program called Multipaint is supplied with the ‘Touchmaster. This provides a demonstration of the facilities provided, but is hardly a comprehensive graphics aid. A plastic template gives a menu of the facilities available, with the selected option displayed in a ‘status’ window at the bottom of the screen. Five different brush types may be used; each of these can be any width from two to 32 pixels, in steps of two pixels. The window also shows the current drawing mode — Dots, Points or Freehand — and the selected

xR | _ ;

foreground and background colours. Colours may be changed by pressing the required option on the menu until the desired choice appears in the status window. : 2

Once the correct colours and brush types have been selected, further options are avilable for the creation of boxes, circles, polygons and ‘rubber- banded’ lines. A stylus is supplied with the package, but finger pressure may be used instead. The Touchmaster, with its larger tablet area, does not suffer from the same restrictions as the Koala-

pad (see page 629): pressure from a finger may be translated into a precise co-ordinate rather than a mere approximation, so electronic finger-painting is a real possibility!

Unfortunately, Multipaint offers no more than rudimentary features. A FILL option is marked on the template and documented in the manuals, but — on the Spectrum version at least — this does not appear to operate in the expected manner. Neither is there any facility for magnification or editing, which means that colours may not be changed. On the Spectrum, where it is often easier to draw in black and white before adding colour, this is a decided disadvantage.

As a piece of hardware the Touchmaster tablet appears to have a lot going for it compared with rivals like the Grafpad and the Koala-pad. It is : robustly built and offers a full A4-sized drawing area that can be connected to most of the more popular home computers. One § significant advantage is that if you decide to upgrade or change your machine in the future, all that is required is a new interface — plus the appropriate software, of course.

It is a disappointment that the documentation and software supplied should be so poor

-compared with the standard of the tablet itself. Touchmaster is bringing out a range of software designed specifically for use with this tablet; |

_ although the real proof of success will come if | independent software houses decide to support it. !

THE HOME COMPUTER ADVANCED COURSE 831

WHO DUNNIT? ©

Our s series s of investigations into the u use e of LOoGO’s list processing facilities continues with a look at how to set up a simple database. We use the example of a murder investigation, in which a list of suspects is created and then analysed to ascertain who | the murderer v was. |

community in the Ozark Mountains. eatich has been viciously attacked with an axe and killed. We know that Matthew and Joshua both own axes, James and Ebenezer own guns, and cousin Jane has a knife. Matthew and James both had blood on their hands when they were questioned by the local sheriff.

Our LoGo database of information about this crime will consist of a list of facts — each of which consists of a relation, together with one or more nouns. When represented in LOGO, one fact is [OWNS MATTHEW AXE] or, in English, ‘Matthew owns an axe’. To represent the fact that James had blood on his hands, we use [BLOODY JAMES].

We begin our investigation with an emply database:

TOSETUP | MAKE “DATABASE [] END

We then add facts to our database as we discover them (providing they are not already in the database). For example, we would input ADD [OWNS JANE KNIFE] using the following ADD _ procedure:

TO ADD :FACT IF NOT MEMBER? :FACT :DATABASE THEN MAKE “DATABASE FPUT :FACT :DATABASE END |

The database will eventually fill up:

[[BLOODY MATTHEW][BLOODY JAMES][KILLED ZACHARIAH AXE] [OWNS MATTHEW AXE] [OWNS JOSHUA AXE] [OWNS JAMES GUN] [OWNS EBENEZER GUN] [OWNS JANE KNIFE]]

To print out the database use SHOW. This can be followed by either “ALL, in which case the whole database will be printed, or by the name of a relation, in which case only the facts for that relation are printed. So, SHOW “OWNS will show us who owns what. TO SHOW :S IF :S = “ALL THEN LIST.ALL :DATABASE LIST.REL :S :DATABASE END

832 THE HOME COMPUTER ADVANCED COURSE

TO LIST.ALL :LIST IF EMPTY? :LIST THEN STOP PRINT FIRST :LIST LIST.ALL BUTFIRST : LIST END | TO LIST.REL :S :LIST IF EMPTY? :LIST THEN STOP | IF :S = FIRST FIRST :LIST THEN PRINT FIRST “LIST LIST.REL :S BUTFIRST :LIST END

Now we must devise ways of querying the database. The simplest kind of query we might make of our database is to check whether a fact is known to be true. This we do with a procedure called DOES, which checks whether a fact is in the database. For example, DOES [OWNS JANE KNIFE] should give the answer YES.

TO DOES :FACT IF MEMBER? :FACT :DATABASE PRINT “YES ELSE PRINT “NO END

It would be much more useful for our investigation

into this terrible murder if we could ask questions

such as “Who owns an axe?’. The way we will deal with this is to use ‘variables’. Any word whose first character is ? will be assumed to be a variable. We can then paraphrase the question as: __

WHICH [OWNS ?SOMEONE AXE]

The reply to this will be a list of all possible values of the variable ?SOMEONE that are consistent with the information in the database.

[?SOMEONE MATTHEW] [?SOMEONE JOSHUA] NO (MORE) ANSWERS

We can have multiple variables. For example: WHICH [KILLED ?MAN ?IMPLEMENT}]

will give the answer:

~ [?MAN ZACHARIAH] [?IMPLEMENT AXE] ~ NO (MORE) ANSWERS

_ Let’s consider the procedures that enable this

analysis of the database, individually. WHICH passes the job over to FIND, indicating DATABASE as the source of facts.

TO WHICH :QUERY FIND :QUERY :DATABASE PRINT [NO (MORE) ANSWERS] END

FIND sets up two global variables, VARS and ANS: VARS is used to hold each possible set of values of the variables in the question, and these are collected together in the list ANS.

TO FIND :QUERIES :DATA MAKE “VARS [] MAKE “ANS [] COMPARE :QUERY :DATA PRINTL :ANS

END

COMPARE looks at each fact in the database in turn. If there is a match then the new set of values in VARS are added to ANS before setting VARS back to the empty list. COMPARE then continues working through the DATABASE to see if there are any other possible matches.

TO COMPARE :QUERY :DATA | IF EMPTY? :DATA THEN STOP IF MATCH? :QUERY FIRST :DATA THEN MAKE “ANS FPUT :VARS :ANS MAKE “VARS [] COMPARE :QUERY BUTFIRST :DATA END

To see what MATCH? does, consider the case where the inputs are [OWNS ?SOMEONE AXE] and [OWNS

JOSHUA AXE] in response to which MATCH? outputs -

TRUE and sets VARS to [?SOMEONE JOSHUA]. If the inputs are [OWNS ?SOMEONE AXE] and [KILLED ZACHARIAH AXE], then MATCH? outputs FALSE.

The real difficulties arise, however, if there is more than one variable involved. VALUE? is used to check if the variable has already been assigned a value for that fact in the database.

We have used here an alternative notation for conditionals in Loco. TEST evaluates a condition. If the result is true then the actions following IFTRUE will be performed, otherwise the actions following IFFALSE will be carried out.

TO MATCH? :QUERY :FACT IF ALLOF EMPTY? ‘QUERY EMPTY? :FACT THEN OUTPUT “TRUE ; TEST FIRST FIRST :QUERY = “? IFTRUE IF NOT VALUE? FIRST :QUERY FIRST “FACT :VARS THEN OUTPUT “FALSE [FFALSE IF NOT ( FIRST :QUERY = FIRST :FACT ) _ THEN OUTPUT “FALSE OUTPUT MATCH? BUTFIRST :QUERY BUTFIRST “FACT se END

To see how VALUE? works, let’s first consider the case where the inputs are ?/MPLEMENT, AXE, and [?MAN ZACHARIAH]. VALUE? tries to ascertain whether the variable ?IMPLEMENT could have the value AXE. There are _ three possibilities:

~?IMPLEMENT already has a value, which is not AXE,

and VALUE? outputs FALSE; ?IMPLEMENT already has the value AXE, and VALUE outputs TRUE; or ?IMPLEMENT does not have a value, so it is given the value AXE, and this information is added to VARS and TRUE is output.

TO VALUE? :NAME :VALUE :VLIST IF EMPTY? :VLIST THEN MAKE “VARS LPUT LIST “NAME :VALUE :VARS OUTPUT “TRUE TEST :NAME = FIRST FIRST :VLIST IFTRUE IF :VALUE = LAST FIRST :VLIST THEN OUTPUT “TRUE ELSE OUTPUT “FALSE OUTPUT VALUE? :NAME :VALUE BUTFIRST “VLIST | END

_ PRINTL simply arranges for the components of ANS

to be printed out below each other.

TO PRINTL :LIST IF EMPTY? :LIST STOP | PRINT FIRST :LIST PRINTL BUTFIRST :LIST END

MORE COMPLEX ENQUIRIES

Our investigation will not go far, however, unless .

we can ask more complex questions, such as “What implement killed Zachariah, and who owns such an implement?’ In Loco, this reads:

WHICH [[KILLED ZACHARIAH ?IMPLEMENT]| [OWNS ?SUSPECT ?IMPLEMENT]]

WHICH now takes a list of queries as input and the values found will be those that make all of the queries true. If you then wish to ask a single query with this new form of WHICH the syntax we use is:

WHICH [[OWNS ?ANY KNIFE]]

We need make only minor alterations to these procedures:

TO WHICH :QUERIES FIND :QUERIES :DATABASE PRINT [NO (MORE) ANSWERS] . END

TO FIND :QUERIES :DATA _ MAKE “VARS [] MAKE “ANS [] COMPARE :QUERIES :DATA PRINTL :ANS END

COMPARE now has a rather difficult job to do. Let’s take [[KILLED ZACHARIAH ?IMPLEMENT][OWNS 2SUSPECT ?IMPLEMENT]] as an example input.

_ COMPARE goes through the database, one fact at a

time, to find a match for the first query, and ends up matching ?IMPLEMENT with AXE. The routine then considers the second query ([OWNS 2SUSPECT ?IMPLEMENT]), starting again from the beginning of the database. A match is found for the second condition, with the value of ?IMPLEMENT as AXE and ?SUSPECT as MATTHEW. There are no more queries, so this is a possible solution. |

But we have not finished yet; there may be other values that satisfy the second query, while keeping ?IMPLEMENT as AXE. So COMPARE now proceeds

_ through the database from the point it left off, and indeed finds a second solution with ?SUSPECT as

JOSHUA. Of course, the procedure does not stop there, but continues searching the DATABASE. ‘This time it reaches the end without finding any new matching values.

It is possible, however, that there is another solution to the first query — other than ?IMPLEMENT as AXE — so we must go back to the point where we found that match in the database and carry on from there. This process is called backtracking. In this case, there are in fact no other solutions. :

THE HOME COMPUTER ADVANCED COURSE 833

In order not to lose track of where it is up to in its assignment of variables, COMPARE puts the present values on a stack before MATCH? is used (since

MATCH? may alter these assignments), and then recovers these values afterwards. Here is the full procedure:

TO COMPARE :QUERIES :DATA | IF EMPTY? :QUERIES THEN MAKE “ANS FPUT ‘VARS :ANS STOP IF EMPTY? :DATA THEN STOP PUSH :VARS TEST MATCH? FIRST :QUERIES FIRST :DATA IFTRUE COMPARE BUTFIRST :QUERIES ‘DATABASE PULL “VARS COMPARE :QUERIES BUTFIRST : DATA 7h. END

In COMPARE we use a stack to keep track of the value of VARS, instead of using a temporary variable, because COMPARE could call itself between the time we want to save the values and the time we want to restore them. Therefore, any such temporary variable could be overwritten by

834 THE HOME COMPUTER ADVANCED COURSE

the next call and the original values lost. ‘The stack prevents this from happening.

PUSH puts a value on ‘top’ of the stack, first creating the variable STACK if it does not already exist.

TO PUSH :DATA

IF NOT THING? :STACK THEN MAKE “STACK (] MAKE “STACK FPUT :DATA :STACK END —

PULL takes an item from the stack, and assigns it as the value of a variable.

TO PULL :‘NAME MAKE :NAME FIRST :STACK MAKE “STACK BUTFIRST :STACK END

~ What we have then are the rudiments of a ‘logic

programming’ language. That is a language in which we simply add facts and rules to a database and then query that database by means of logical descriptions of the data we require. The best

_example to date of a logic programming language

iS PROLOG — but that’s another story!

DAVID HIGHAM

See CuGE

i Senseo

A special type of electric motor called a ‘stepper’ motor is used to power the Workshop. robot. Stepper motors are favoured for computer control because they use logic signals to control their speed and rotation through discrete steps and are thus ideally suited to digital control.

HES

2 aE GaU a uuu e inne stan ese anaemia RAR eR Ra i

The construction of a stepper motor is very different from that of a normal motor. To

understand the principles of operation we shall

consider how a simplified stepper motor works. In our example (see the diagram headed ‘One Step At A Time’) there are two set of windings (‘a’ and ‘b’) on the stator and two pairs of electromagnetic poles on the rotor. In the motors that are used in the Workshop robot there are more stator windings and more rotor poles than our example shows. 3

The only problem with this convenient form of motor control is that the motor consumes as much current when stationary as it does when in motion. In addition, it cannot be rotated at high speed — the different coils cannot energise and de-energise quickly .enough. However neither of these problems is significant in our robot application.

Our simplified motor is capable of turning in steps of 45° only. Additionally, the direction of rotation cannot be controlled. The motors used in the robot, however, have four sets of coils that are energised in pairs, and the rotor also has many more coils than our example shows. This means that the direction of rotation may be controlled and that the step angle is reduced to 7.5°. To

achieve this accurate stepwise rotation, the four

coils must be energised in a particular and

complicated sequence as follows:

Stator Coils Energising Sequence Table Step Coil A ColB . CoilC Coil D

1 on off. on. off 2 off ON on off a off on One on 4 on off off on o on. off on Olt, sete

This sequence of energisation could be provided by software, using four bits of the user port to control the four coils. However, this requires some complicated programming and Basic could certainly not produce these control sequences quickly enough. A simpler method is to use a chip that has been specially designed for the control of stepper motors — the SAA 1027. This contains the output drivers and all the logic circuits to energise the coils in the correct order to drive a stepper motor.

To rotate the motor through one step, a single pulse from the user port is required, with a further signal line being needed to determine the direction of rotation. The chip contains input stages to detect the changes in the three inputs: a pulse to rotate the motor one more step, areset input, anda direction input that reverses the stator coils energising sequence. The inputs are fed into a bi- directional counter circuit to produce the correct output sequence to the stator coils.

Finally, the chip also contains a power output driver stage that can handle up to 5|00mW. The inclusion of this stage means that the motor can be

THE HOME COMPUTER ADVANCED COURSE 835

The Driving Force Although the logic of the Stepper motor driving chips is complex, the principles of operation are easily understood. In order to turn the rotor the Stator coils must be energised ‘ina certain sequence. A bi- directional counter moves through this sequence a stage at a time in response to a pulse signal. The sequence can also be stepped through in the Opposite direction if the direction line input is changed, causing the rotor to turn in the opposite direction. A third input allows the rotor to be reset to its position at the beginning of the sequence, If required

connected directly to the chip without the need for external power transistors. :

The complexity of the stepper motor driver chip means that the rest of the circuit needed for the robot control is very simple indeed. Each motor requires one of these chips, to which the motor is connected. Unfortunately, the driver chips operate at a voltage of about 12 volts, while your computer user port operates at five volts. That is, a logic zero is zero volts (or thereabouts) and a one is five volts. The driver chip inputs require zero volts for a zero input and between 7.5 and 12 volts for a one. To interface the user port to the driver chips we therefore also need a special two-voltage buffer chip with the inputs operating on one voltage and the outputs on another. This is the 40109 chip that is also needed in the circuit.

pecasoaoasente ss Risnnokusisn Rae URS Be EOC Dan uoaninn re ausnagay eenrensuyist &

pase Bas 8. aenneaaee onc

Repeat ess a

os EA

eats aaa vogan:

ee 3h SSRN e ae SRR REREAD DORON Se Baee aa AAR RU RAARa aS Beane sofa an 3 : pasa

Bes e Dlvoguunvanaae 5 Rei s ae

ee fe oo mee Te ne PER

Baas CRS B

eae akan

Riss ie ee

Be peas PERS Ah: a

Rare

cua

Bay BRS On eS

y :

Bees NaRono

eae RRaou one

Past eid

Renee

ies Paonia aa

IER She

3 =

soe

Riis Rae

eae Se

Bie one

eee Bes

eee penne

spat hee SaaS

Soy

Sih

ges

Scr

SENOS

KEVIN JONES

LIZ DIXON

MOTOR 1

MOTOR 2

O4F CAPACITOR D C

| SAA 1027 CAPACITOR DRIVER CHIP

EARTH

SAA 1027 DRIVER CHIP

D3 D2

27092 RESISTOR 100Q RESISTOR ;

SAA 1027 pu DRIVER CHIP

| TRACK BREAK

KEVIN JONES

The Circuit Diagram

The circuitry required to drive the two stepper motors is Straightforward, two SAA 1027 driver chips being used to provide the correct coil energising Sequence to each motor. As the driver chips operate at 12v and user port signals from your micro are only ov, an additional buffer chip is used to isolate the 12v circuitry from the computer and translate the low voltage user port signals into the higher voltage signals needed by the driver chips. In the next instalment we shall show how the circuit board connects to the motors and D plug and how to make the correct connections with the computer’s user port

| THE HOME COMPUTER ADVANCED COURSE 837

H { |

WUT ia MIGANN

SEU mee Rees me

BYTE THE DUST

to its conclusion with this instalment. We tie up all the loose ends of our debugging program, provide an overall view of the flow of command within it, and finally code the

SHES ERS Se Sa EE

The first task of the main module is to set up th interrupt mechanism, which allows us to set breakpoints in the program being debugged. These transfer control to the debugger and allow us to inspect the contents of the registers and memory locations. We must then obtain the starting address of the program being debugged so that control can be passed to it using the S$ command. The rest of the main routine involves getting commands from the keyboard and executing them; control is transferred to the program being debugged by the S and G commands and returned to the debugger by the SWI instructions inserted at the breakpoints. Two stages of initialisation for this module were

- coded in the last instalment (see page 817). The _ entry point for interrupts comes immediately after

the call to this subroutine. The first instruction here is to save the stack pointer, S so that it can be used to reference the values from the registers saved on the stack by the SWI. The next stage is command interpretation. We have already developed subroutines to perform all the commands, so the problem here is to select the subroutine appropriate to the command entered.

It is possible to code this as a set of nested IF statements, but we will use the fact that the Get-

~ Command routine returns an offset into a table of

command characters to perform these calls using a jump table. This is not perhaps the most efficient method in this instance, but it is a useful technique that is worth looking at. It involves setting up a table of addresses for each of the subroutines that actually carry out a command.

The JMP instruction, unlike the branch instructions, can use any of the normal addressing modes, including indexed and indirect. If we load

-X with the base address of the table and use the

offset in B (doubled because this will be a table of 16-bit addresses, unlike the table of eight-bit command letters), then the command:

JMP [B,X]

will transfer control to the appropriate subroutine. The BSR call is made to the address of this jump instruction. As we need to set up this table in advance, it is necessary to have another stage of initialisation to carry out this operation.

PROCESS SET-UP-JUMP-TABLE Data: Jump-Table is a table of eight 16-bit addresses CMDB, CMDU, etc. are the start addresses for the Subroutines

Process:

For each subroutine

Get start address

Save start address in Jump-Table Endfor

We must now consider what is to happen at the end of the run, when the quit command (Q) is issued, although there is, in fact, very little that needs doing. It makes sense to leave both the debugger and the program intact so that they can be re-entered if necessary. |

The stack should be in the same situation when we exit as it was when we started. One solution would be to use a separate stack for our program by setting S to a new value and then restoring the old value. This is often a useful technique, but in our situation it may be difficult finding unused space in memory, with the debugger sitting on top of another program. Another solution is simply to increment S by the appropriate amount to lose anything that we have left there, but this is also difficult because we do not know whether or not an interrupt has occurred and the amounts on the stack will be different. The simplest solution is to save the initial value of S and restore it as the last operation of the program.

The interrupt mechanism, as set up in the initialisation procedure, stores three bytes at the address given in the SWI vector at SFFFA; we must restore this or strange results may occur if the operating system uses SWI for its own purposes. What we clearly need is a further stage of initialisation where we save these values to be restored in our quit routine.

PROCESS SAVE-VALUES

Data: : | Saved is the five bytes to store the saved values Stack-Pointer is the current value of S, plus two SWI-Vector is found at SFFFA

Process: Save Stack-Pointer in Saved Get SWl-Vector Save three bytes at SWl-Vector in Saved

The quit routine (command Q) must simply reverse this process and transfer control back to the operating system. This can be done in a number of ways: the SWI instruction itself can be used, after its vector has been reset, or a jump can be made to a known entry point in the operating

system. A jump via the reset vector that resides at Reset-Vector is at SFFFE SFFFE is guaranteed to return control to the

- | Process: 7 3 Program Flow a u Id start. SPCR RSE usa x jee Restore three bytes from Saved at SWI-Vector These Res rueaen -Po; correspond to the debugger PROCESS QUIT eee ee program modules. They are Data: pee gery | placed in the order in which they Saved is the five bytes to store the saved values We are now ready to code the main module. The Winnthoalatene abe Stack-Pointer is the current value of S, plus two design has altered slightly from when we first — ¢oloured blue indicate separate SWI-Vector is at SFFFA sketched it out, but it remains essentially the same. __ routines being called Main Module | Set-Up-Jump-Table Set-Up Interrupt Command Module

ARNRALERS

OLS E

Command G

THE HOME COMPUTER ADVANCED COURSE 839

LIZ DIXON

jz, Subroutine, WY redefining register usage. This is not really

THE MAIN MODULE

Data: Prompt for command entry is ASCII character ‘> Command-Offset into table of command characters and Jump-Table Process: Save-Values Set-Up-Jump- Table Set-Up-Interrupt Get Start-Address _ Repeat Display Prompt —Get-Command Do-Command Indefinitely

That completes our debugger program. At the moment it is rather fragmented, but that is a consequence of modular construction. At this point we can optimise the code if we wish by looking for short cuts. For example, you may find that you have had to move a lot of values around to make sure that they are in the right registers for a so you might make savings by

advisable unless memory space is very restricted. We have defined the same data areas in a number of different places, as they are required. ‘There are two ways in which you might handle data areas in the complete program: you can retain the data with the module that uses it, which is theoretically

the best option; or you can define all the data

together at the start of the program, which has real advantages if you ever want to use a disassembler (or even a debugger) on the program. _

The debugger should be loaded into any spare memory not occupied or used by the program to be debugged. It is entered by making ajump to the DEBUG entry point, so it is necessary to know this address before you start.

In the later part of this 6809 machine code series, we have tried to show the best way in which programs are developed, illustrated with a variety of techniques. Therefore, the design of our debugger program is not necessarily the most efficient way to do this particular job. If you have followed everything, however, then you should have a fairly comprehensive understanding of Assembly language programming in general, and 6809 Assembly in particular.

Set-Up- Jump-Table ADDD- #2 se care of the STABLE Space for 8 two-byte STD X++ Save it addresses LDY SFFFA Get Interrupt vector address SETUPJ LEAY JTABLE,PCR _ Base address of table in Y LDA Y+ Get first byte to be saved LEAX CMDB,PCR Start address of CMDB STA X ‘cae subroutine : SIX ,Y++ Store it in table Cl oa LEAX CMDU,PCR Start address of CMDU ae a ao subroutine RTS STX ++ Store it in table Command Q Ss eS CMDQ —LEAX ~—SAVED,PCR —_Address of Saved STX Y++ Store it in table LDY SFFFA SWI-Vector LEAX CMDS,PCR Start address of CMDS LDA 2,X First of three bytes subroutine STA Yt Restored STX Y++ Store it in table LDD 3,X -Other two bytes LEAX CMDG,PCR Start address of CMDG STD iv Restored subroutine LDS iX Saved Stack-Pointer STX ay Store it in table JMP [SFFFE] Indirect jump via reset vector LEAX CMDR,PCR a ies of CMDR Main Module STIX Y++ Store it in table PROMPT ~ FCB >. LEAX CMDM,PCR__ Start address of CMDM STACKP RMB 2 Stack-Pointer for Display- : subroutine Registers STX tt Storeitintable = DEBUG BSR SAVEIT © Save-Values : LEAX CMDQ,PCR Start address of CMDQ BSR SETUPJ Set-Up-Jump-Table | subroutine BSR INIT Set-Up-Interrupt and Get STX ++ Store it in table Start-Address This is the actual jump to the subroutine. We assume that X ENTRY STS STACKP,PCR _ Save Stack-Pointer contains the address of JTABLE and B the offset LEAX JTABLE,PCR DOCMD JMP [B,X] REPT02 LDA PROMPT,PCR _ Get prompt and BSR OUTCH display it Save-Values BSR GETCOM Get Command SAVED RMB 5 Five bytes to be saved © LSLB | Double offset for 16-bit table SAVEIT LEAX SAVED,PCR Get address to save in BSR DOCMD Obey Command TFR S,D Move S to D BRA REPT02 Next Command

840 THE HOME COMPUTER ADVANCED COURSE

Here, courtesy of Oric Products International, we publish the first instalment of the 6502 programmers’ reference card

DESCRIPTION IMPLIED | IMMED | PAGE ae

ADD WITH CARRY 69 | 65 LOGICAL AND : 25 ARITHMETIC SHIFT LEFT 06 BRANCH ON CARRY CLEAR

BRANCH ONCARRY SET

we ae Bont RELATIVE ADDRESS | ADDRESS

6D 2D

BRANCH IF EQUAL TO ZERO

COMPARE BITS WITH ~ ACCUMULATOR

BRANCH ON MINUS BRANCH ON NOT EQUAL TO ZERO BRANCH ON PLUS

BREAK

BRANCH ON OVERFLOW CLEAR BRANCH ON OVERFLOW SET CLEAR CARRY

CLEAR DECIMAL

COs ACS CO | C4

C6 fee

CLEAR INTERRUPT MASK CLEAR OVERFLOW FLAG

| COMPARE TO ACCUMULATOR | COMPARE TO REG-X / COMPARE TO REG-Y¥3 DECREMENT MEMORY DECREMENT REG-X DECREMENT REG-Y EXCLUSIVE OR ACCUMULATOR INCREMENT MEMORY INCREMENT REG-X X ‘t

INCREMENT REG-Y Y JUMP TO ADDRESS PC

2 ED SLD

S xx ca

KA Re OR KO ee

a i oi & ~¥ q f i NE Be i & é ae s ae e rene or rs : : 4 i ni 2 ce

3 fs F S -

; escent es ¥ ?

aku, F

F ¢ A " ss Fe pa

\ribemeanonenenaia

es a