Echo #03 31 марта 1997

Программирование

Book - Secrets ZX-Spectrum: System Procedures.

   Chapter 8.


   C & S T E M E N Li

   P R O C E D U r s



   For programming in Assembler Z80,
Rom (ROM) ZX-SPECTRUM is a valuable repository of ready-made 
and well-functioning procedures native. Some of them may be a

successfully used with the level of the Basic
creating additional features not available in another way. We 
restrict ourselves description of critical system processes.




   8. 1 Work with sound


   In the ZX-SPECTRUM speaker can be excited
in two ways.


   BEEPER # 03B5 (949) This procedure requires 2 parameters. 
The register is placed DE the duration of sound, and the 
register HL - frequency. These values, before placing them in 
the registers, require the prior conversion. Suppose we want to 
get the tone with a frequency and duration of F T. Then, DE is 
loaded F * T, a in the HL 437500/F-30, 125. Avoid these

calculations can be calling another procedure.


   BEEP # 03F8 (1016) It requires a set
time and frequency of sound in normal units. These parameters 
are passed BEEP by placing them in a stack calculator. BEEP 
takes them out on their own, serves are necessary 
transformations and causes BEEPER.



   BEEPER little better instructions ZX-BASIC BEEP with the 
view that it not subject to restrictions on the parameter 
values. data are controlled in time transformations performed 
BEEP. In time generation of sound all interrupts are 
prohibited. The last statement before BEEPER implementation of 
RET is EL. 



   8. 2 Work with a tape recorder


   As headers and data blocks are recorded on tape by the same 
procedure: 


   SAVE BYTES # 04C2 (1218). Registers DE
must be on the length of zapisyvemogo block
in the IX - the address of the first byte, and in buffer A -
recordable unit:


   TYPE 0 - TITLE

   TYPE 255 (# FF) - UNIT DATA


   In principle, they differ in that the title is preceded by a 
longer entrance signal (about 5 seconds) than

block of data (about 2 seconds). User
may use other values
type between 0 and 255 for type designation
block. This is useful in designating different
types of data in special applications.
Such blocks are ignored instructions LOAD
in reading (not displayed on them
no data), and some programs
copying.


   Standard header always consists of
17 bytes of data:


   1 byte - the type of data block:

   0 - BASIC Program;

   1 - a numeric array;

   2 - a landmark array;

   3 - a set of bytes.

   2 .. 11 bytes - the name length of 10 bytes.
Allowed all the codes from 0 to 255. If
the name is shorter than 10 bytes, then it is padded with 
blanks. 

   12, 13 bytes - length of the block, the next
the header.

   14-17 bytes - depends on the type of set:


   - For type 0:


   14-15 bytes - number of line start-up, refusal to start is 
signaled by the value 32,767 more (# 7FFF).


   16-17 bytes - the length of the program without
field variables.


   - For types 1 and 2 are only
15 bytes for the job (odnoliternogo) name
zapisyvemogo array (the name under which he
stored in variables.


   - For Type 3:


   14-15 bytes - starting memory address, in
which is a lot at the time of writing.


   The above header format must be maintained only for those 
cases where the described Blocks must be read instruction LOAD.



   Reading the written instruction sets is:


   LOAD BYTES # 0556 (1566)


   As well as for SAVE BYTES. Before calling in a couple of 
puts the length of the retrieved DE block in the IX - starting 
memory address for recording unit, and A - the type of the 
retrieved set. Additionally, still need to set a pointer to C 
instruction SCF. Call this procedure with a null pointer C 
eliminates the verification of the block (similar to the 
command VERIFY). Possible Error reading or verification 
signaled zeroing pointer C after leaving the subroutine. Normal 
execution is signaled by the installation procedure C = 1.



   8. 3 Displaying and Printing


   Displaying the single character code
which is in the buffer at the top
or bottom of the screen and the printer is performed by the 
same procedure. Before her call to open the appropriate channel 
using the procedure: 


   CHAN OPEN # 1601 (5633).


   In the buffer must be a sign
desired channel: 1-for "K", 2 for
"S" and 3 for the "P". This channel will be open
as long as we do not close.
If after that to issue a command assembler:


   RST # 10,


   then it will print a single character,
located in buffer A, the selected channel. Program below 
illustrates the application of RST # 10. Its implementation 
tantamount to the team: 


   PRINT FLASH 1; AT5, 3; "X"; # 3; "A".



   LD A, 2; open

   CALL CHAN_OPEN; channel "S"

   LD A, # 12, the character code FLASH

   RST # 10;

   LD A, 1; argument FLASH

   RST # 10;

   LD A, # 16; character code AT

   RST # 10;

   LD A, 5; arguments AT

   RST # 10;

   LD A, 3;

   RST # 10;

   LD A, # 58; code "X"

   RST # 10;

   LD A, 3; open

   CALL CHAN_OPEN; channel "P"

   LD A, # 41, the character code "A"

   RST # 10;

   RET; exit podprog
                       FRAMEWORK

Note that the sign "A" will be sent to the printer buffer, and 
in fact will Printed on paper only after the buffer is full, 
transfer to the buffer line ending character (13) or call: 


   COPY_BUFF # 0ECD (3789).


   This example shows that the shipment
chain of characters, one character can
be extremely tedious. Easier to apply
procedure:


   PR_STRING # 203C (8252).


   It prints a string of characters, whose address is given in 
the registers of DE, the length of BC. Before her call to open 
the appropriate channel. If the printable characters do not 
specify color, they are set based on variables FTTR_T, MASK_T, 
and and odd bits P_FLAG.



   Print numbers more difficult, so
as is necessary to translate a binary number in the sequence of 
characters its decimal representation. All the necessary 
calculations and executes printing procedure: 


   PRINT_FP # 2DE3 (11,747).


   It removes from the stack calculator 5
bytes, counting their numbers in the format adopted in the 
ZX-BASIC. Then prints them based on system variables 
determining the color, position, and so on. Methods placement 
of numbers on the stack, we stipulate below. 


   In the case of natural numbers from 0 to 9999
You can use a faster procedure:


   OUT_NUM1 # 1A18 (6683).


   It prints the number contained in the BC
A 4-fields. Outputting first necessary
number of spaces, ZX-SPECTRUM uses this
procedure to print line numbers in the program listing.



   8. 4 screen graphics


   To draw on the screen we have analogues procedures PLOT, 
DRAW and CIRCLE. 


   PLOT_SUB # 22E5 (8933)


   - Allows you to display on the screen, single point with 
coordinates (X, Y). Before calling to place X in C and Y in B. 


   PIXEL_ADD # 22AA (8874)


   - After entering in the BC values ​​(Y, X)
and call this function, we get the registers HL byte address, 
which describes this point on the screen. In addition to the 
buffer fills the X MOD 8, specifying what kind of bit of the 
byte in question. 


   DRAW_1 # 2477 (9335)


   - Captures the stack calculator
X and Y, and then draws the appropriate
segment. Coordinates are selected from the PLOT
system variables.


   DRAW_3 # 24BA (9402)


   - To draw a similar interval
this procedure, you must specify ABS Y ->
B, ABS X -> C, SGN Y -> D SGN X -> E.


   DRAW_ARC # 2394 (9108)


   - Draws an arc fragments. Options X, Y,
Z for this procedure must be passed
through a stack calculator. Z is placed
top of the stack.


   CIRCLE_1 # 2320 (9005)


   - Draws a complete circle with center
(X, Y) and radius Z. All options also
should be placed in a stack calculator.


   NOTE: The above procedure
modify registers H, L (see the chapter "System Errors").


   Following the withdrawal of the desired image on the screen,
it can be printed out. Analogue
How-COPY is the procedure:


   COPY # 0EAC (3756) - This procedure copies the printer 22 
top rows. 


   Parameters of all the above procedures
subject to the same restrictions as the corresponding commands 
in BASIC. 



   8. 5 Cleaning and moving screen


   CLS # 0D68 (3435)


   - The basic procedure for cleaning the screen.
Ee action is analogous to Directive
with the same name.


   CLS_LOWER # 0D6E (3438)


   - Clean the bottom of the screen. She
acts on the entire bottom of the screen regardless of its 
current size, and simultaneously sets the height of two lines. 
Initialized and system variables and DF_CL SPOSNL, determining 
the position of the cursor. 


   CL_LINE # 0E44 (3652)


   - Cleaning up, starting with the bottom edge of the screen, 
a specified number of rows. The number of rows contained in the 
register B. 


   Before calling these procedures should be
Make sure the channels are open. Two
first of them left after the canal
"K" open. Erasing a color screen
established on the basis of system variables BORDCR to the 
bottom of the screen, and also ATTR_P and MASK_P to the top 
after what their content is copied in ATTR_T and

MASK_T.


   CL_SC_ALL # 0DFE (3582)


   - Moves the contents of the entire screen
(24 full lines) one line up
(Top row disappears.) It can be accessed directly from BASIC, 
because it does not require parameters.



   CL_SCROLL # 0E00 (3584)


   - After entering in the register B of
row-1 for the shift (at least 2), this procedure will advance 
by one line as lines as you want without touching above. 
Consequently, we can be at the top of the screen image or text 
that are not destroyed by a shift by one line.



   Applying these procedures must be remembered
that will rise up as the required attributes at the bottom of 
the screen. 


   8. 6 read keyboard


   Information from the keyboard is most advantageous
remove c system variable LAST_K.
Check the condition of the fifth bit variable
FLAGS, we can determine is pressed or not pressed another 
button (1-pressed New, 0 is not pressed yet none since the 
reset of this bit). After reading the code buttons, reset this 
bit, we provide yourself the opportunity to know, modified,

Do More content LAST_K or not. It acts only when the masked 
interrupt mode 1. It is in this case, the ZX-SPECTRUM 
automatically calls the procedure 50 times a second: 


   KEYBOARD # 02BF (703)


   She watches all of the keyboard, identifying the right 
combination of keys, puts the read code to the clipboard, as 
well as variable KASK_K and establishes the fifth bit FLAGS. 
Interpretation of the pressed key will be depend on three 
system variables. We first checked the contents of MMODE,

regarded as a signed integer in the code
two's complement:


   MODE-1 <0 represents the cursor K, L, or
C

   MODE-1 = 0 represents the cursor E

   MODE-1> 0 denotes a cursor cursor K G
of L and C differs by a third bit variable FLAGS. 0 means that 
K, and 1 indicates L or C. The third bit FLAGS

finally determines whether the cursor
L (0) or C (1). This procedure does not expect
keystroke.


   So that regardless of the state of the cursor
clarify whether a particular key is pressed, more productive 
can be a direct survey of the keyboard with the help of How-IN. 
Here we proceed as As in the case of a function with the same 
name in BASIC. 



   8. 7 Calculator


   Various actions on the floating-point numbers are performed 
using a large set of procedures that occupy space on the ROM # 
2F9B (12187) to # 3860 (14,445). The calculator is called the 
instruction RST # 28, which performs the transition to Address 
# 3358 (131457). 


   The basis of the calculator is 66
different procedures, performs a set of basic operations on a 
stack calculator. Priorities for their implementation is given 
chain bytes, placed directly behind the team RST # 28. The end 
of this chain is always marked by a byte with a value of # 38 
(56). 


   As required, we restrict the operations that allow to 
perform various numerical calculations. Assume that the top

stack are the numbers ... Z, X, Y.

 _______________________________________
| | | |
| Then. | | The state stack |
|-------| Operation | after |
| DEC | HEX | | operation |
|---|---|----------|--------------------|
| 1 | # 01 | change | ... Z Y X |
| | | Items | |
| 3 | # 03 | subtraction | ... Z XY |
| 4 | # 04 | multiplication | ... ZX * Y |
| 5 | # 05 | division | ... Z X / Y |
| 6 | # 06 | degree | ... Z X ** Y |
| 15 | # 0F | addition | ... Z X + Y |
| 27 | # 1B | change | ... Z XY |
| | | Mark | |
| 31 | # 1F | sine | ... Z X SIN Y |
| 32 | # 20 | cosine | ... Z X COS Y |
| 33 | # 21 | tan | ... Z X TG Y |
| 34 | # 21 | sine | ... Z X ASN Y |
| 35 | # 23 | arccosine | ... ZX ACS Y |
| 36 | # 24 | arctangent | ... ZX ATG Y |
| 37 | # 25 | log | ... Z X LN Y |
| | | Natural. | |
| 38 | # 26 | Exhibitor | ... ZX EXP Y |
| 39 | # 27 | integer | ... Z X NT Y |
| | | Of | |
| | | Number | |
| 40 | # 28 | root | ... Z X SQR Y |
| | | Square. | |
| 41 | # 29 | number sign | ... ZX SGN Y |
| 42 | # 2A | absolute | ... ZX ABS Y |
| | | Value | |
| 49 | # 31 | copying-| ... Z X Y Y |
| | | Of the stack | |
| 50 | # 32 | N MOD M | ... Z residues. Privacy |
| 52 | # 34 | append | ... Z X Y D |
| | | Stack | |
| 56 | # 38 | end | ... Z X Y |
| | | Payments | |
| 88 | # 3A | INT (Y +0.5) | ... Z X INT (Y + .5) |
| 160 | # A0 | Append 0 | ... Z X Y 0 |
| 161 | # A1 | Append 1 | ... Z X Y 1 |
| 162 | # A2 | Append | ... Z X Y 0.5 |
| | | 0.5 | |
| 163 | # A3 | Append | ... Z X Y PI / 2 |
| | | PI / 2 | |
| 164 | # A4 | Append | ... Z X Y 10 |
| | | 10 | |
|___|___|__________|____________________|


   As an example of using the calculator
calculate the value of 1. 5 * SIN (X)
+ X ** 2 * COS (X * PI / 2). Assume that the value
X is on top of the stack. Accommodation for
construction of RST # 28 to read the first byte
Speakers will:
 _______________________________________
| | |
| Byte | Condition stack |
|-----|---------------------------------|
| # 31 | X X |
| # 31 | X X X |
| # 31 | X X X X |
| # A3 | X X X X PI / 2 |
| # 04 | X X X X * PI / 2 |
| # 20 | X X X COS (XPI / 2) |
| # 04 | X X X * COS (X * PI / 2) |
| # 20 | X X * X * COS (X * PI / 2) |
| # 04 | X * X * COS (X * PI / 2) X |
| # 01 | X * X * COS (X * PI / 2) SIN (X) |
| # 1F | Append 1.3 (5 bytes) |
| # 34 | 1 |
| # F1 | 2 |
| # 26 | 3 |
| # 66 | 4 |
| # 66 | 5 |
| # 66 | X * X * COS (X * PI / 2) SIN (X) 1.3 |
| # 04 | X * X * COS (X * PI / 2) 1.3 * SIN (X) |
| # 0F | X * X * COS (X * PI / 2) +1.3 * SIN (X) |
| # 38 | end computing |
|_____|_________________________________|


   Explanation requires an entry in the calculator stack data 
as a sequence bytes following immediately behind the # 34.

Bytes # F1 # 26 # 66 # 66 # 66 represent the number of
2 ** 113 * 0. 13 rather than 0. 13. This is due to
interpreting them as numbers in the truncated
record. The scheme is as follows:


   - First byte is divided by # 40 (64) and as
the exponent is taken:
the remainder of this division, plus # 50 (if
it is different from 0), or the next byte plus
# 50 (if the remainder is 0);


   - Integral part of the division of (0, 1, 2, 3)
plus 1 determines how much demanded
bytes for the mantissa. Missing up to 5 bytes
filled with zeroes.


   In our example, # F1 (241) divided by the
# 40 (64) gives the residue # 31 (49), as well as
kiss part 3. This means that the exponent of our number is
# 31 + # 50 = # 81 and requested that all 4 bytes
mantissa. In this system, the number 0 is
submission # 40 # B0 # 00, since 0 divided
at # 40 gives a remainder equal and integral part
0. Then becomes the second byte + # 50 or
# B0 + # 50 = 00 (all these calculations on the individual
bytes being modulo 256) and is given by
only the first byte of mantissa. The remaining bytes
(5) supplemented by zeros. In turn,
number 10 has the representation
# 40 # 80 # 00 # 0A.


   Glyph # 34 allows you to place the numbers in
Throughout the program in assembly language. However,
often required to put on the stack parameters
instructions or values ​​calculated in
program. To do this meant a lot
ancillary procedures. They allow
as extracting value from the stack and
Writing to the different numbers:


   STK_TO_BC # 2307 (8967)


   - The next two for a number (a 5-
byte representation) are extracted from
stack and inserted into registers B and C. Their
values ​​should be in the range from -255
255. Otherwise the refund in
BASIC with the message B (to be completed
User RST # 8). This procedure can
applied to negative numbers. Their
characters are returned in registers D and E. Numbers derived 
from the stack, rounded to nearest whole number.



   STK_TO_A # 2314 (8980)


   - A procedure similar to the previous one, with
except that the stack is removed
only one number, and after rounding up
placed in a buffer. Sign of returning to the register C.


   STACK_FETCH # 2BF1 (11249)


   - This procedure removes from the stack, all
number (5 bytes) and places it in the registers A, E, D, C, B.


   FP_TO_BC # 2DA2 (11682)


   - Number of stack is rounded to the nearest whole number and 
mix of register BC. The sign is determined by the number of 
index Z (0 - for negative) if the value in the stack exceeds 
the maximum 65535, then the pointer is set to 1 and

this is the only reaction to error (return to the ZX-BASIC is 
not happening). 


   STK_STORE # 2AB6 (10934)


   - This procedure places the top of the stack
5 bytes of the registers A, E, D, C, B. Number
1.3 (# 81 # 26 # 66 # 66 # 66) can add to the stack
calculator 2 ways (note that the second method allows you to 
save 3 bytes: 


   LD A, # 81 RST # 28

   LD DE, # 6626 or DEFB # 34

   LD BC, # 6666 DEFB # F1

   CALL # 2AB6 DEFB # 26

                           DEFB # 66


   STACK_A # 2D28 (11560)


   - The value of register A periodically
entered into the stack in a 5-byte representation.


   STACK_BC # 2D2B (11563)


   - This procedure is similar to the previous
but the stack is stored with the register number of BC.



   After completion of payments calculator
Registers HL locates the address of the first
5 bytes are at the top of the stack. When you work with a 
calculator to cares about the related work with a stack. It 
should also be remembered that the procedure PRINT_FP removes 
from the stack the printed number. At the end of the present 
challenge of the program Native pseudorandom generator

numbers:


   LD A, # A5

   CALL STACK_A

   RST # 28

   DEFB # 2F

   DEFB # 1D

   DEFB # 38

   RET


   This program puts the next pseudorandom number in the top of 
the stack and updates the system variable SEED. 



   8. 8 Additional system procedures


   SET_MIN # 16B0 (5808)


   - Generates a global clean working areas of BASIC, as well 
as stack calculator. It modifies the system

variables indicating the relevant
memory area. Physically overwritten only those bytes that are 
recorded Indices the end of the field.



   MAKE_ROOM # 1655 (5717)


   - Calling it should be in registers HL
give the address of the start byte extension block
and BC block size. The procedure itself
establishes what the system variables
must be modified in the case
need to modify them. Consequently, it allows insertion into an 
existing program in BASIC or in the region new variables, 
operators, variables and etc..



   RECLAIM_2 # 19E8 (8168)


   - Contact the previous function. Here in
HL recorded address of the first byte that
should be removed, and the BC size erase block. Also, as 
before, the relevant system variables will be automatically 
modified. 


   CLFAR_BUFF # 0EEF (8815)


   - How to clean printer buffer and
modifies the related system variables.


   LINE_ADDR # 196E (6510)


   - Finding the row address with the specified
number in the program in BASIC. Before calling the number 
recorded in the HL searched line. The output of the HL, we have 
addressed this line or the first with a large number. If

line with a given number is, it is
indicated by the pointer Z.


   FREE_MEM # 1F1A (7962)


   - Identification of free memory for BASIC, ie, between 
STKEND and RAMTOP. Registers HL and BC contain the same

a negative number represented in the code
additions to 2, is the difference between
STKEND +80 and SP (stack pointer processor
Z80).


   BREAK_KEY # 1F54 (8020)


   - Her call to verify the rollover  and . If
they are pressed, the pointer C reset.