0: 174270

              32: 0             

The first word is the address of the dispatcher. The second is the word that is loaded into the processor status word (PS) when entering the interrupt routine. 0 means that all interrupts are allowed while the EMT manager is running.

The following is a block diagram of an EMT dispatcher with explanations:             

The diagram shows that the dispatcher calls the subroutine, the address of which is determined by the following formula:

              Adr = (160000 + XXX), where XXX is the low byte of EMT.

In other words, from the address 160000, a table is stored that contains the addresses of the desired routines. Of course, the low byte of EMT should be even, in order to avoid misunderstandings in the processor.

ROM addresses from 160000 to 160012 store some interrupt vectors, therefore EMT with low bytes is used, starting with 14. There are only 10 useful routines called by the EMT manager. A list of them is given in the appendix. The remaining routines consist of one command - RETURN.

<Scheme 4.0>

              4.2 TRAP dispatcher.             

The TRAP dispatcher vector is written at address 34:

              34: 174344

              36: 200

The second word says that during the operation of the TRAP-manager interrupts from the network and programmable timers, from the keyboard, from the RESET command in the CPU, from channel interruptions will be prohibited.

The block diagram of the TRAP dispatcher looks like this:

              <Scheme 4.1>

The routine address is calculated as follows:

              Adr = (160160 + XXX), where XXX is the low byte of TRAP.

Those. subprogram addresses are stored from address 160160. There are only 3 of these subprograms, i.e. only three TRAP commands make sense:

              TRAP 0,

              TRAP 2,

              TRAP 4.

              The difference between them and EMT routines is that they should end on RTI, and not on RETURN.

                            Summary to §4:

§five. The general scheme of output to the screen.

              5.0 Buffer and its structure .               

              Information on the screen is sent byte by byte. Each processor can have access to the output of symbolic and graphic information to the terminal. For this, each processor has its own path.

The CPU sends information through K0. PP sends it through EMT commands. But in any case, these bytes are written to a special area of ​​the RAM RAM called the buffer. It is located in addresses from 2000 to 2177 (200 bytes).

The buffer allows you not to wait until the sent byte is displayed on the screen (in one way or another), and represents a "queue" of bytes ready for processing (output) - Fig. 5.0.

              <Figure 5.0>

The variable in the RAM RAM (22544) is a pointer to the tail of this queue. That is, it contains the address of the cell where the next incoming package will be recorded (from the CPU or the PC).

              5.1 Writing to the buffer from K0.             

When recording from the CPU to channel K0, with an allowed interrupt from the receiver, the interrupt from the receiver 320. If interrupts are disabled, then there is another way to read information from K0 into the buffer - this is the TRAP 4 command. Then, if the message was valid (the readiness bit was set in the receiver), the information is read into the buffer from the corresponding data register.

Both bp from K0 and TRAP 4 are essentially the same program, but with different entry points (Figure 5.1).

              <Scheme 5.1>

A few more variables are used here. Their meaning is as follows:

              Table 5.1

              5.2 Writing to the buffer from the software.             

The buffer can also be replenished from the PP. Three commands can be used for this: EMT 42, EMT 44 and EMT 46.

EMT 42 writes the low byte of R0 to the buffer, EMT 44 - the line whose address is contained in the word following the command, and EMT 46 - the line with the address in R1.

Figure 5.2 shows the execution of these commands. Since EMT routines can also be called via CALL, the diagram shows the addresses of additional entry points.

              <Scheme 5.2>

If you execute, for example, such an excerpt from the program:

                            JSR R5, @ # 117204             

                            .WORD A             

                            .

                            .

              A: ASCIZ / *** WHY DO YOU EMT 44? *** /             

then a line is loaded into the buffer, the starting address of which is A. This will be somewhat faster than using the fragment:

                            EMT 44             

                            .WORD A             

                            .

                            .

              A: ASCIZ / *** WHAT WOULD YOU DO WITHOUT EMT 44? *** /             

              since the call to the EMT dispatcher is bypassed.

Note that with the buffer pointer after the increase, the & ~ 200 command is executed, which prevents it from exceeding the value 2177.

                            Summary to §5:

• There are two ways to output to the terminal - from the CPU through K0 and from the PC through EMT 42, 44 and 46.

• In all cases, the bytes to be output are written to the buffer — a memory area in the RAM of the memory card. Addresses occupied by the buffer - from 2000 to 2 177.

• A buffer is like a queue. Bytes are written to the buffer at the address pointed to by the pointer variable. Its address is 22544. After writing, the value of the pointer increases by 1.

• From channel K0, the byte goes to the buffer in two cases:

- the interrupt from the receiver K0 is triggered.         

- when calling TRAP 4.         

• Information can be written from the RAM RAM to the buffer using the following methods (see table 5.2):

              Table 5.2

Immediate display methods differ by executing TRAP 0 at the end of the subroutine.

§6. TRAP 0, or Process Manager. Management strategy.             

Of all the procedures performed by the software, TRAP 0 is perhaps the most necessary and indispensable. In addition to the output to the screen, she is responsible for many other I / O functions, as well as some internal functions.

TRAP 0 can also be called a process manager , which coordinates the work of external devices, adjusting to their needs (and to the needs of the user, in the end) all the resources that are wired into ROM.

The TRAP 0 routine itself is laconic. It is just short (you can take a look at the 6.0 scheme). However, understanding her work immediately will be quite difficult. Therefore, in a simplified manner, we consider the "management strategy" in the RAM RAM.

              6.0 Management Strategy.             

              We trace what happens in the criminal code when the power is turned on.

1. The software starts up and starts working from the address 160300. This is the start address of the initial start-up program (PNZ).

2. PNZ stops the CPU (just in case), copies the programs necessary for normal operation to the CPU RAM, and starts the CPU.

3. Then comes the test control of memory and processors. Its results are remembered.

4. Initialization of external and internal devices is performed, standard interrupts are suspended from them, RAM RAM is created (i.e., the initial values ​​of some variables are loaded). Note that screen initialization is performed using the EMT 40.

5. According to the results of the start test, in case of an error, a diagnosis message is issued, for example: "Start test ROM error 2", indicating that the 2nd bank of the ROM is faulty.

6. There is a transition to the process manager, to the point @. (We will distinguish between TRAP 0 and the process manager as the entry point. If you enter the point @, we assume that the process manager is working).

              Further, all the work of the software goes through the process manager. How does this happen?

              6.1 Requests. Query and process tables.             

There is a table in RAM RAM at addresses from 7060 to 7102. We will call it a query table and try to explain this name.

Each word in the table has its own task:

              7060 - processing information from the keyboard,

              7062 - loading from WU,

              7064 - screen output,

              7066 - cursor control,

              7070 - menu "Setting modes",

              7072 - me "Download",

              7074 - work with the printer,

              7076 - start a user routine,

              7100 - testing,

              7102 - exit to the process manager (back).

Their normal state is zero. If you need to perform any of the above processes, 1 is added to the contents of the corresponding cell.

The process manager works on a cycle basis and scans the query table in its work. Having found a cell from the table nonzero (and he looks through them in order), the dispatcher calls the corresponding subroutine, i.e. the process itself. The addresses of such routines compose their own label — a table of process addresses.

This table is located in the ROM at the addresses 174232 ... 174252, i.e. contains 9 addresses. The last cell in the query table 7102 does not match the address in the process address table.

How and when does the contents of the query table change? We have already met with cell 7064 - each time it is written to the byte buffer, it is incremented. As you can see from the table, this cell is really responsible for the on-screen output. If it is set (not equal to 0), the dispatcher starts the screen output routine, and it already processes the information written to the buffer, subtracting the unit from (7064) after each processed byte. This is repeated until the cell is reset to zero. Then there is a return to the process manager and the scan continues.

Other processes treat their request cells in a similar way, with some decrementing and others immediately zeroing them out.

The increase or installation of requests is carried out "from the side", mainly by interrupts: from the keyboard, from channels, from the network timer.

The cell with the address 7102 - the last of the query tables - does not change its value - 1, and serves to resume the cycle of the process manager.

              6.3 Table of vectors. Calling processes through TRAP 0.             

Immediately after the query table in RAM, another table follows - the table of vectors. If one of the processes is executing, and another process must be executed from it without completing the current one, then TRAP 0 is called (as is done from EMT 44, for example). The vector of the interrupted process, or rather, the current address is rewritten in the vector table. In it, each cell also corresponds to a process. The difference between the addresses of the "same" cells of the query table and the vector table is 24.

By executing the process for which it was called, TRAP 0 finds the installed cell in the query table. Depending on the contents of the vector table (or rather, its cell to which the established request corresponds), TRAP 0 either returns to the interrupted old process via JMP (in the vector table - a nonzero vector) or starts the process via CALL (in the vector table - 0) .

Minor subtlety: TRAP 0 cannot execute a process that is “below” the one from which it was called. That is, called from the screen output program (request address - 7064), it will not reach requests whose addresses are more than 7064 and can only process keyboards and external devices. Therefore, the processes are arranged in decreasing order of importance.

              Example 12. Interception of requests.             

The vector table is the most convenient loophole for intercepting processing of requests for processes. Let's try to intercept the processing of requests for the cursor tracking process.

In the PP monitor, record the following:

              41000 : 042737 BIC # 200, @ # 177716                                                       

                            000 200

                            177716

                            052737 BIS # 200, @ # 177716                                         

                            000200

                            177716

                            004737 CALL @ # 176056                           

                            176056

                            012737 MOV # 41000, @ # 7112                                         

                            041000

                            007112

                            000137 JMP @ # 174222                           

                            174222

              7112: 041000             

Each time you access the cursor tracking process, a piezodynamic click will now sound.

              6.4 Internal and external procedures.             

All procedures executed by the software can be divided into internal and external relative to the process manager. Internal - processes controlled by the dispatcher. External ones are subroutines not controlled by the dispatcher (interrupt routine).

External procedures do not have the right to call TRAP 0, this will lead to the fact that the process manager will "fly out" of the loop and the machine will freeze.

The addresses of the vector query tables, as well as the contents of the task table are shown in table 6.0:

              Table 6.0.

Example 13. Interception of a cycle of the manager of processes. Method 1

              The last word of the vector table 7126 contains the number 174222 (address of the restart of the process manager). In principle, nothing prevents you from writing another address there, and do something like continue the process manager on it.

              Our process will remain the same - click:

              41100: 042737 BIC # 200, @ # 177716                                                       

                            000200

                            177716             

                            052737 BIS # 200, @ # 177716                                         

                            000200

                            177716

                            000137 JMP @ # 174230                           

                            174230

              7112: 000000             

              7126: 041100             

              Do not be surprised, however, that after the changes made, everything will remain as it were, as it were - quiet and smooth. The PP monitor is the reason for this - it is part of the "Installation" menu process, and as long as you are in it, the process manager will not reach the end of the query table, which means that it will also restart request. Exit this menu, and if you do not immediately get into the "Download" menu, which, by the way, is one of the processes, you will hear sound with a frequency of about 10 kHz.

Example 14. Interception of a cycle of a manager of processes. Method 2             

Let's see what happens if you reset the restart vector of the process manager: (7126) = 0. Then the dispatcher will process the restart process through CALL, taking the address from the table of process addresses in the ROM. But such an address is not provided for the restart process, and the dispatcher will take the first cell after the table. Its contents are 13700, which means that the subroutine will be called at address 13700. This is the second way to bring the dispatcher cycle to its ending. The exit from this ending should be through RETURN.

              13700: 000137 JMP @ # 41200                                         

                            041200

              41200: 042737 BIC # 200, @ # 177716                                                       

                            000200

                            177716

                            052737 BIS # 200, @ # 177716                                         

                            000200

                            177716

                            000207 RETURN             

              7126: 000000             

Filling this example and exiting all the menus, you will hear a sound. So, we taught the process manager to whistle.

                            Summary to §6:

• ROM includes:

1. Bootstrap program.
2. Process Manager (aka TRAP 0).
3. Interrupt routines.
4. All the rest.

              Everything that is included in paragraph 4 is called by the process manager.

• When you start or restart the computer after the initial startup program, control is transferred to the process manager. It differs from TRAP 0 only in its entry point.

• The process manager works on a cycle basis. In his work, he scans 10 cells in RAM RAM, called the query table. Each cell in this table has a specific subroutine called a process.

• If you set non-zero one of the cells in the query table (set the request to execute the process), the process manager will start this process. A list of process addresses is a process table.

• Processes decrement or nullify the request.

• TRAP 0 can only be called from processes. Since TRAP 0 is an interrupt, the vector of the interrupted process is stored in the vector table. This ensures the recursion of processes in the UKSC: the dispatcher calls the process, he can call TRAP 0, which will start another process, etc.

• Upon completion, TRAP 0 exits on the vector of the interrupted program.

• The last word of the query table always contains 1, and the last word of the vector table must contain 174222 (address of the restart of the process manager). This achieves the dispatch loop.

• All procedures performed by the software can be divided into two categories:

              1) internal to the process manager (the processes themselves),

              2) external to it (initial start-up program, interrupt routines).

Chapter 3 . Standard screen output.      

§7. Screen Separation.

So, we figured out the buffer and the dispatcher. Consider this ordinary situation: the software “circles” in the Manager, scanning the query table and looking forward to the execution task.

Now let the CPU send a byte on channel K0 (it does not matter which one so far). The interrupt from the receiver K0 from the PP will work. Our byte will be written to the buffer, the buffer pointer will change.

Cell (7064) in the query table will also be installed. The interrupt routine ends and control returns to the Manager. It detects that a request has been received for screen maintenance (cell (7064) is not 0) and starts the screen output routine, the address of which is in the task table.

This address is 111144.

It is hardly worth rushing to describe this subroutine right away. Actually, it’s not very complicated. It will simply be more convenient to approach her from the other side.

7.0 The principle of separation of screens.

Of the many tricks laid down in the Criminal Code by developers, this, at first glance, does not strike the eye. However, without it, the Criminal Code is not the Criminal Code.

Suppose you are working in BASIC, or in the remote debugger, and it was necessary, for example, to change the color of the symbol. What are you doing? Press the "SET" key. What's happening? The "Set Modes" menu appears. Having performed the necessary manipulations with this menu, you return again to the same environment where you were, by pressing the "ISP" or "Enter" keys.

In this case, you do not find any changes in the current screen. Even the cursor is in the same place.

In other words, the work in the “Set” menu did not concern your program and your screen. This work was carried out in a different screen. How did this other screen fit in instead of the main working one? Of course, using the row table. She began to point to other addresses at WHO, and thus made visible video information in another area of ​​video memory.

This is the principle of screen separation in the Criminal Code. Instead of copying arrays of video information, preserving the old image, just a few cells in the table of rows just change, and as a result, you see a new screen.

7.1 Standard screens in UK-NTs.

Since the table of lines indicates entire lines, and not their segments, screens in the Criminal Code are horizontal "stripes" over the entire width of the screen, of different heights and locations on the screen.

The system supports 4 standard screens (see Fig. 7.0).

Two of them can be called screens with a stretch. They represent a character string each - service (at the top) and information (at the bottom). These "screens" are always present on the terminal. Each of them contains 40 familiarity.

The service line is used to display the current alphabet (RUS / LAT), indicate the inversion modes, underline, additional keyboard (INV, PODCH, DKL), the mode of indication of control characters (MIS), the mode "Setting modes" (SET). The developers provide for the output of some other inscriptions to the top line, but for some reason the System does not use these features.

The lower info line is not used at all in the System.

For output to these lines are intended EMT 52 and EMT 56. But more about them later. So far, another 2 screens are in line.

They are displayed in the "window" between the service line and the info line. One - let's call him a worker - the most important in the Criminal Code. Almost all user programs work in it.

This screen contains 26 character strings of 80 characters maximum. Of these 26 lines, 24 are always displayed, and the remaining two can be viewed by cyclically moving the screen up or down using terminal commands (UPR + R or UPR + V). Only in this screen does the roll operate, and the "Set Modes" menu changes the modes of this screen (changes colors, the format of the working screen, the type of roll).

And the last standard screen is the service one. It contains 20 character strings, with a maximum of 40 characters each. The roll in this screen is always off. The service screen is used to place the "Set Modes" menu, as well as under the PP monitor.

Enter this monitor as follows: call the "Setup" menu by pressing SET, and then press GRAPH + ICP or UPR + @. Work in the PC monitor is similar to work in the CPU monitor. However, hanging the car here is much easier. Exiting it in the "Settings" menu is done by pressing Ctrl + C.

Each screen in the row table has its own color and display control registers. Their addresses are given in table 7.1. Recall that each of these registers occupies 2 words in the row table.

Table 7.1 Display and color control register addresses for standard screens.

The cell with address 2476 contains information about which screen - working or service - will be displayed in the window:

1) working screen: (2476) = 2500

2) service screen: (2476) = 4672.

7.2 Screen maps.

It is clear how screens are displayed and how to display, for example, a service screen instead of a working one. But how is the output organized in each screen so that there is a complete separation of the screens? And is it possible to design your screens so that the output in them was carried out using standard software as easily and conveniently as in the working screen?

It turns out you can.

The output to the screen requires the placement in RAM of some variables, for example, the color of the character, familiarity, current address in the WHO, etc. So that the screen separation is complete, each of the screens has its own SAO

H8jshchiuschaya, etc. Then the call to the variables will be

look like this:

   Bias Assembler Flowchart

     10 10 (R5) (R5 + 10)

      2 2 (R5) (R5 + 2 )

Table 7.2 shows the displacements of the variables, their meaning, as well as the characteristic values ​​for each of the four screens.

<Table 7.2 Screen maps>

A detailed use of variables from on-screen maps will be given below, together with an on-screen output algorithm.

              Example 15. Eternal lines.             

Enter the PP monitor. Before you - a service screen. Let's decorate it with some decent, but indelible inscriptions.

By pressing D, you will be in terminal mode. Clear the screen - <RESET>, and make some decent inscription on the top line. Then exit this mode - <OPR> + C.

Now, to fix the inscription made, we will change some variables of the screen map:

              1) (+2): (22756) = 155430 (shift the starting address of the WHOU “down”),

              2) (+30) :( 23004) = 5104 ("lower" the address of the top video line in the row table),

              3) (+14) :( 22770) = 312 (reduce the number of erased video lines by 11) :,

              4) (+12) :( 22766) = 23 (reduce by 1 the number of character strings).

By these actions, we excluded our line from the service screen, although it will remain on the screen. Now you can be sure that only the initialization of the screen or a direct intrusion into the video memory will be able to erase the inscription made.

You can remove protection from the first line by bringing the changed EC cells to their original state (it is given in the application).

Summary to §7.

• To create a user-friendly interface, it is convenient to organize multi-screen output. The principle of separation of screens allows you to do this.

• The row table may point to different screens. The screen in the Criminal Code is a horizontal strip on the terminal, consisting of consecutive video lines.

• To display the desired screen, just “direct” the route of the row table along the desired channel. To do this, as a rule, you need to change the contents of only one cell in the row table.

• The system supports 4 standard screens:

Top service line.

Working screen.

Service screen.

Bottom info line.

• Each screen has its own WHOU area.

• Service and information lines are always displayed on the screen (above and below). Between them, either the work screen or the service screen can be turned on. Their switching is done using the cell (2476). The working screen corresponds to the value 2500, the service - 4672.

• The output to each screen is completely independent. This is achieved using screen maps.

• Screen map - a table of variables for screen output. Each screen has its own, and consists of 31 words. The starting address of the current EC is stored in cell (23150).

• To organize the output to the desired screen, it is necessary to write in the cell (23150) the starting address of the map of the desired screen.

• The starting addresses of the four screen cards are:

22560 - upper service line,

22656 - working screen,

22754 - service screen,

23052 - bottom info line.

§eight. Screen output program.

We’ll start with the most important on-screen output program. Scheme 8.0 gives its algorithm. The beginning of important sections is marked with marks (M ...).

The description of this program is perhaps the most boring place in the chapter, therefore resorting to reading this verse should only be necessary. If there is none, we suggest you skip immediately to the summary, which is on page ....

So, we started ...

M0 ... M1 (addresses 111144-111202):

> A cell (7066) is set from the query table, indicating that the cursor should be highlighted.

> R5 is loaded from cell 23150 by the start address of the current screen map.

> The color code registers of the dot and background are loaded from the screen map:

      RT from (R5 + 34),

      RF from (R5 + 40).

   Note that both words of the Russian Federation are loaded from the same variable.

> In the display control register, the cursor color from the cell (R5 + 70) is written in the 1st byte. In this cell, in addition to color, you can specify the type of cursor (graphic or symbolic), as well as the position of the graphic cursor in the octet.

* So, the colors of the point and familiarity are loaded. The cursor is ready to be turned on.

M1 ... M2 (addresses 111204-111230):

> 1 byte is written from the buffer to R0.

Cell (22542) serves as a buffer pointer when displayed. Its difference from the cell (22544) is as follows:

    (22544) indicates the place in the buffer where the next byte is written (buffer head).

    (22542) indicates where the new byte (tail) should be read from in the buffer (see Fig. 8.0).

    <Fig. 8.0 Little picture-explanation>

It is clear that (22542) must point to an address no greater than that pointed to (22544) (head always ahead of tail):

   (22542) <= (22544).

> The pointer-tail is changed - (22542). It is incremented, and to prevent the exit of the buffer limits, the & ~ 200 command is executed on it.

> The number 111126 is written to the stack. This is done so that when the RETURN command is sent from anywhere, control is transferred to the address 111126 (and not immediately to the Dispatcher).

> The least significant byte is allocated from R0.

* So, a byte is written from the buffer to R0. RETURN output control intercepted.

M2 ... (addresses 111232 ...):

> Depending on the value of R0, the contents are interpreted either as a control code (less than 40) or as a character (more than 40).

1. MANAGING CODE:

> Depending on the contents of the cell (22552), the control code is either displayed on the screen (MIS mode - indication of control characters) or the control code is being “executed”.

    a) (22552) <> 0 - "ISU":

M21 ... M22 (addresses 111730-112020):

> A three-digit octal number equal to the control code is printed in angle brackets.

M22 ... RETURN (addresses 112022 ... 113036):

> If the control code is 12 (VK), a "carriage return" is performed (code 25).

    b) (22552) = 0 - not "ISU":

M20 ...

> The content of R0 is multiplied by 2, 13142 is added to the result. The resulting number is the address of the cell that contains the address of the corresponding special function. (For special features, see below.)

> Goes to the address of the special function.

2. SYMBOL.

M3 ... M4 (addresses 111260 ... 111314):

> If R0> = 100, the contents of the cell (22556) are added to it by OR. This cell is used to switch between alphabets (Russian / latinsky).

> The content of R0 is multiplied by 2, 14142 is added to the result - the starting address of the character generator table. The word from the cell with the resulting address is written in R1. This is the address of the character generator (a plate containing 11 bytes). Each byte in the GP represents a section of a symbol, i.e. an octet.

> R0 is loaded from (R5 + 10) by a step in the WHOU between the video lines.

> In R2, 177010 (address of RA) is written, in R3, 177024 (address of RO). In RA, the current WHO address is written in this screen (first word EC).

* So, everything is ready to draw a symbol:

   R1 indicates a character generator,

   R0 contains a step in who

   R2, R3 contain the addresses of the registers of the addresses of the plans and the octet.

   RA is loaded with the current WHO address.

M4 ... M5 (addresses 111316-111420):

> The contents of the cell (R5 + 56) are added to the instruction counter. If inversion or underline modes are not enabled, this variable is 0. When you enable the corresponding mode, it is loaded with a certain value. Then control is transferred to the address calculated as follows:

      A = 111322 + (R5 + 56).

> If this is the normal mode, then all 11 bytes from the character generator are transferred to WHO through the RO. At the same time, the set digits in these bytes correspond to the color of the character, and to the reset digits - the color of familiarity. If inversion, bytes are inverted before being written to an octet. If underscore, the last byte is replaced with 377.

* So, the symbol is drawn.

M5 ... M9.

> 1. is added to the current WHO address (first EC unit) 1. From (R5 + 16) 1. is subtracted. Cell (R5 + 16) shows the character position in the line, starting from the right edge. For extreme right familiarity, this cell is 1. Are you still reading? It’s strange.

> If the resulting value (R5 + 16) is different from 0 (the right edge is not reached), RETURN is executed.

* Well ... The current position of familiarity (along the X axis) has been changed.

> If (R5 + 16) = 0 (right edge of the screen), a transition to a new character string is performed. At the same time, the contents (R5 + 4) are copied to (R5 + 16), which is equal to the number of characters in the line displayed on this screen. By the way, this number is not necessarily equal to the number of octets in this mode (80, 40, 20

or 10).

> The current address in the row table - (R5 + 32) - increases by 54 (the difference in the addresses of the elements is through 11 video lines).

> The current WHO address - (R5) - records the contents of the variable (R5 + 22). This cell contains the number of familiarity (left), which begins the output in a row.

> In case the end of the row table is detected, i.e. the current address of the row table is equal to the final:

    (R5 + 32) = (R5 + 26),

The current address becomes the starting one: (R5 + 32): = (R5 + 24).

> To the current WHO address - (R5) - the WHO address is added to which the current element of the row table indicates. The number of the current character string is reduced by 1 (it is considered from the bottom):

   DEC 20 (R5).

* The position on Y has changed (in the case of switching to a new character string).

> If this is not the bottom line on the screen - (R5 + 20) is not 0 - RETURN is executed.

M12 ...

> Otherwise (bottom line) - there is a choice - scroll the roll one character line up (roll on) or not scroll (off). The last variable of the screen map is responsible for the state of the roll (on-off) - (R5 + 74).

   ... M13 - roll off:

> The output is again from the top of the screen. To do this, the current address in the row table becomes the address of the top row, and the current WHO address is the corresponding WHO address + indent from the left edge.

> The number of the current character string (counted from the bottom) becomes the maximum :

    (R5 + 20): = (R5 + 12).

Then exit on RETURN.

   ... M14-M15 - the roll is on.

> In this case (R5 + 20) is incremented.

> 13 is written to the stack. This is the screen offset when scrolling.

> 54 is added to the address of the top row in the row table, indicating that after scrolling the roll, the top row on the screen will be another (11 video lines lower).

> If the address of the top row in the row table is 4670 (end address), it is replaced by 2500 (start address).

      M15 ...

> Here the roll is being set for scrolling. Checks the roll counter - cell (23170). If it is empty (equal to 0), the cursor is extinguished, a new character string is cleared (which has not yet been displayed - it is below, beyond the horizon):

        CALL 113344,

and a number from the stack (13) is added to the counter. If the counter at the time of verification was greater than 14 (modulo), TRAP 0 is executed. Then R5 is loaded from (23150) and everything is lost with M15.

The roll is scrolled through a network timer. The operation of the timer program is described in Chapter 5. For now, we only note that cell (23170) is responsible for the roll: its contents show how many pixels you need to scroll the screen. Positive values ​​correspond to scrolling up, negative values ​​(in the additional code) - down.

* So, the algorithm of the program is disassembled.

Now it remains to consider what happens when RETURN is executed from this program.

As already noted, on RETURN control is transferred to the address 111126. Here, the following is done:

> 1 is subtracted from (7064), i.e. 1 request is removed.

> If (7064) becomes equal to 0 (no requests), and also there is no buffer overflow ((22546) = 0), the program exits to the Manager via RETURN.

> If (7064) is not 0, (there are still requests for on-screen output), the cell (7060) containing requests from the keyboard is checked. If the latter are absent ((7060) = 0), we return to our procedure, to label M1, and everything repeats.

If, nevertheless, there is a request for a keyboard, an exit to the Manager is performed to satisfy this request.

> Finding the buffer full, ((22546) = 2), TRAP 4 is called (it reads the byte from the channel). Another request is added to (7064), and again to address 111126.

* Thus, the exit to the dispatcher is carried out:

  1) If there are requests for the keyboard and the screen. 2) When running out of screen requests, if the buffer is not full.

For those who have little time to understand the algorithm, and just lazy people (that is, for almost everyone):

Summary to §8,

which briefly describes how screen output works and how it handles screen cards:

• The screen map aims to tell the world how the screen is designed and in what state it is now (and whether it is in general).

• Those variables that report the screen device will be called static, since they have not changed since the creation of the screen map. 
• Those variables that can be changed (mainly with the help of special functions, which we will touch upon soon), are called semi-dynamic. A characteristic variable of this group is "symbol color", for example.

• And finally, the variables that change almost every time the character is displayed (for example, the position of the current familiarity on the screen) will be called dynamic.

We group each group of variables in tables.

  <Here, in theory, there are 3 tables: 8.1, 8.2, 8.3>

  <And here also - figure 8.4 - Active screen page>

• And, briefly, the work of the program itself:

1) The colors of the symbol and familiarity, as well as the cursor, are loaded from the EC into the video registers. The cursor turns on.

2) Bytes are taken from the buffer. His character is checked. If it is less than 40 (bytes, not character), then this is the control code, a certain address corresponds to it. Management is transferred to this address.

If byte> = 40, then this is a character. It should be displayed on the screen.

3) The output to the screen is carried out from the character generator (ZG). ZG is a plate in which each code (symbol) corresponds to 11 bytes. These 11 bytes make up one character on the screen (11 * 8 points).

There are 3 display modes:

- normal

- inversion (all bytes are displayed inverted on the screen),

- underscore (the lowest byte of any character is displayed "filled in" - the number 377).

4) After the character is displayed, the current familiarity changes its position (the corresponding variables in the EC change).

5) If necessary, a command is given to “spin” the roll 11 video lines up (the screen is full).

6) If there are still bytes in the buffer that need to be "processed", everything is repeated from step 2.

However, if at the same time there is a request from the keyboard, the manager is logged out.

Also, the exit to the Dispatcher occurs when the requests are exhausted (the buffer is empty).

§9. Special functions

9.0 ' ЎlOzhl § Є®ЈҐҐa v®a E bЇҐzhdgЄzhO ©.                  

, Ž ‡ "PP Ґbvm 2 ЎlOzhl Ї® 0.5 ЉЎ © Je in r¤ n., Je r¤® © O§ det in ЄO¬ ®Ўa §®¬, b®¤ҐarOvbp 256 (400) bl®ў . '® Ґbvm loЎ®¬g § zҐёо Ў © in (0 ... 255) b®®vўҐvbvўgҐv Ї® bl®ўg ў Є r¤® © in ЎлёжҐ.            

' ЎlOzh § Є®ЈҐҐa v®a (' ‡ ø) S £ Ґvbp b ¤aҐb 14142., ∞ © ea pvbp ¤aҐb § Є®ЈҐҐa v®a - v.Ґ. ¤aҐb 11 ¡The © vle in ЎlOzҐЄ, Je avO®Є ¤lp Je r¤®Ј® Є®¤ (0 ... 255). 'in ¤ Aulus © § Є®ЈҐҐa v®a § iOv ¢ ‡ P ", and the table is set for it, ie, indicates addresses in ROM.                           

If you wish, you can make your character generator, and set up a table on it. To accommodate an alternative character generator, memory is allocated in the RAM of the software - these are addresses from 15142 to 22540. Here, nobody will disturb your PG, unless another lover of inventing alphabets.

The table of special functions (TSF) begins with the address 13142. The addresses are also stored in it. But these are already addresses of subprograms called special functions. Each code has its own SF.

9.1 Calling special functions. Code 33.

We have already seen how special functions with codes up to 40 are called up: the screen output program, upon detecting such a code, is immediately sent to the address that it finds in the table of special functions (TSF).

But what about codes from 40? After all, the screen output program will interpret such a byte as a character. To show the System that it is necessary to respond to this code with a special function, control code 33 is intended. 33 is placed before the required code, and this couple is interpreted as SF.

How does this happen? Take a look at diagram 9.0. It gives a block diagram of the SF-33, as well as a block diagram of one irreplaceable subroutine.

So, having received code 33, the System called SF-33. This SF works as follows.

 The stack pointer is stored in cell (23152). Cell (23174) becomes equal to 2. This shows that work is going on "through 33" .       

 The subroutine with the address 110762 is called, after which our byte (following code 33) appears in R0.       

 Next comes the call to the desired special function, zeroing the cell (23174), restoring the stack pointer and returning.       

  Everything is clear here (at least to the author). Now let's see what is done in subroutine 110762.

 Like a screen output program, work with the buffer is going on here. Having detected the arrival of the next byte following 33 ((7064) is not equal to 0), the subroutine writes the desired code to R0.       

 If it is from 40, it returns from the subroutine. Otherwise (less than 40), the corresponding special function is called (right there, inside this payment order), and upon exiting the SF, again, at the beginning of the payment order. An exception is made for code 33 - when it is detected, an “ejection” occurs in SF-33, to a point with the address 113544.       

 If the code has not yet arrived, (7064) = 0, the dispatcher goes out to enter the subroutine from address 110726 when it arrives again. When the buffer is full, TRAP 4 is called, and again the beginning of the subroutine.       

9.2 Actions of special functions.

Now consider all the standard special features. For this purpose, all algorithms (except the most trivial ones) are presented in diagram 9.1, and the actions of special functions are summarized in table 9.2.

Note that not for each code there is an address in the SF table that is different from 0. For codes addressing 0, there is no special function (address 0 contains a thoughtful RETURN command). These special functions are not listed in the table.

In the table, by the cursor we mean both the hardware cursor itself and the place where it can be displayed, i.e. current familiarity.

<Unmeasured Scheme 9.1>

<No less measured table 9.2>

9.3 Definition of keys and character generator through SF-120.

Let's consider one special function in more detail. Its code is 120, and she is responsible for two tasks at once:

• key definition
• override character encoding.

     Key Programming.

The keys in the UK-NTs are called 5 keys - K1, K2, K3, K4, K5. They are designed so that in one click the terminal sends a string - a package of several bytes. Moreover, these keys can be called from five registers:

• normal:      1-5,                           
• lower (NR):     6-10,                                  
• pseudographics (GRAPH): 11-15,
• control codes (CRC): 15-20,
• - register "FIX":    21-25.             

The total number of keys is therefore 25. Each key can be assigned its own inscription. How is this done through the SF-120? It’s very strange.

The key number must be set not in the usual binary, but in decimal form. Those. if you need to determine the key number 18, instead of one byte equal to 18, you send 2 numbers: 1 and 8. The special function composes a binary number from them.

Another bleak moment: the key values ​​are set in hexadecimal form. Therefore, instead of 12, say, a byte, you have to send 24 hexadecimal digits (characters from "0" to "9" and from "A" to "F").

And further. Initially, the special function provides the ability to redefine keys. What it is?

Key strings are written to a special area of ​​RAM software. The current address in this area contains cell (13140). The location of the key area is from 11142 to 13130. Each time a key is determined, after writing a line, the pointer moves closer to the end of the area. When overridden, the pointer becomes 11142 (the beginning of the region), and all keys become empty.

However, a small mistake in the body of the special function precludes this possibility. The fact is that in the package one byte is responsible for the redefinition - it is called the sign of redefining keys. Here is a view of a standard package specifying keys:

Symbol: <33> P; <P> | <Cl1> / <Page1>; ...; <ClN> / <StRN>; <33> /

Code: 33 120 73 P 174 Kl1 57 Str1 73 73 KlN 57 StN 73 33 K

Here <Cl> is the key number (in decimal),             

              <page> - string (in hexadecimal format),

                K is an arbitrary code (greater than 37).

<P> means, by design, a sign of redefinition. If it is even (the least significant bit is 0), the keys are redefined. An odd sign (the least significant bit is 1) means that the lines are still written from the current place, and the rest of the keys are not changed. The attribute must have a value of at least 40.

However, the error led to the fact that it is not the sign of overriding that is being analyzed, but the previous byte (code 73). It is clear that it will remain odd until the end of the century, and therefore it will not work to return the pointer to its original value.

Why is that bad? Because the area of ​​RAM in which the keys are stored (more precisely, the lines to them) is limited. It is a little less than 1 Kbyte. If a sufficiently large number of programs redefining keys have worked on the machine, this area may become clogged, and then redefining the keys will fail again. Approaching the border of this area, the SF-120 will, as if nothing had happened, receive bytes, but will not be determined - the pointer (cell with address 13140) will not increase.

The keyboard section of the book shows how you can very easily redefine keys, and how, for example, make any key in an arbitrary register key.

   Recoding the character generator.

There are also enough oddities here. Here is the parcel format for transcoding:

Character: <33> P; <code>; @ <obr1>; ...; <obrN> <33> /

Code: 33 120 73 Code 73 100 obr1 73 ... 73 obrN 33 K

Here <Code> is the character code, starting from which you want to transcode the character generator.

<obr> is a transcoding pattern.

K is an arbitrary code (greater than 37) .

The sample is defined as follows. Familiarity (11 * 8) is divided into 2 parts - the upper (5 * 8) and lower (6 * 8) - Fig. 9.3.

              <Figure 9.3. Familiarity breakdown for SF-120>

Then each of the parts is divided into 8 vertically. It turns out 16 numbers: X1 ... X16.

The number 100 is added to each of them:

Y1 = X1 + 100, etc.

The bytes received make up the sample:

Y1 Y2 Y3 Y4 Y5 Y6 Y7 Y8 / Y9 Y10 Y11 Y12 Y13 Y14 Y15 Y16

As a separator, you can use any code from 40. In one package, you can write at least the entire character generator.

Not only is it impractical - instead of 11 bytes to send 17 (16 + separator), it is also quite a long time. In addition, in this part of the special functions, there were no errors. In the character generator (in the address range from 15142 to 22540), the address of the plate for each code should be calculated as follows:

A = 15142 + Code * 13, since each code corresponds to 13 (octal!) Bytes.

And in SF-120 this address is calculated as follows:

A = 15142 + Code * 11.

If you record the entire CG with one package, the error may not affect. But if, for example, we write down one part of a GP from a certain code and then continue with a different premise, the second part may overlap with the first, and you will not have to expect anything good from such a PG.

Summary to §9.

• Each code considered by the screen output program can be interpreted either as a symbol or as a control code.

• Symbol: each code corresponds to a word in the table of the character generator (TZG). This word refers to a plate of 11 bytes representing 1 character. The combination of these plates is a character generator (ZG). TZG is located at addresses 14142 ... 15140.

• Control code: each code corresponds to a word in the table of special functions (TSF). This word contains the address of a subroutine called a special function (SF). Special functions are located in the ROM and perform mainly screen display tasks. The TSF is located at 13142 ... 14140.

• Codes less than 40 always cause special functions. If you need to call the SF with a code of 40, it is preceded by code 33.

§ten. EMT 52, 56, 40.

Now we’ll deal with three EMT subroutines. Two of them - EMT 52 and EMT 56 are used to output to the service (upper) and information (lower) lines. EMT 40 is used to initialize the screen.

10.0 Output to the service and information lines (EMT 52, 56).

So, EMT 52 and 56. If you wish, you can take a look at 10.0. Block diagrams of these routines are given here. More precisely, the subroutine is only one, but the entry points are different. EMT 52 sets the address 22560 (service line) at the beginning of the current screen map, and EMT 56 - 23052 (informational). In addition, you can "protect" the service line from inscriptions through EMT 52 - for this you need to set cell (7150) to 2.

These routines are not buffered. Bytes are output immediately from the line whose address is placed behind the EMT command. The first byte in this line is always interpreted as the X position on the screen. The string should end with 0.

Another small nuance. EMT 52 and 56 uses the standard on-screen screen output program with the address of the entry point to it 111272 for character output. This means that control codes (0 ... 37) will not be control codes here. They will not cause special functions, but are displayed in the form of characters (in the character generator you can write characters for such words).

10.1 Initialization of the screen (EMT 40).

When executing the initial start-up program, the software should, among other tasks, initialize the screen. What it is? This is a sequence of actions leading from scratch to the normal operation of the screen. Initialization includes:

1) WHO cleaning;

2) preparation of K0 for receiving bytes;

3) building a row table;

4) building a table of character generator;

5) building a table of special functions;

6) buffer initialization;

7) some initial settings (such as turning on the cursor).

All these actions are performed by EMT 40. His arrangement is shown in diagram 10.1. In addition to the initial entry point, some additional addresses are shown here.

If, for example, you do not need to clear the screen, but just need to rebuild the table of lines, TG, TSF, etc., you can call the subroutine through CALL from the following addresses:

Address Starting point (of the above)

107754 1                           

110022 2                           

110044 3                           

110050 4                           

110076 5                           

110114 6                           

110 136 7                           

Of course, first you need to save the registers you still need on the stack (when calling through EMT, you do not need to save the registers).

Now we will describe some procedures called from EMT 40.

Procedure 110266. Builds a table of rows. As already mentioned, this table consists of individual elements. Each item must contain the WHO address and the address of the next item. First, the "skeleton" of the table is built - the addresses of consecutive elements are written. Then, using procedure 110550, the WHO addresses are written to the table. And last but not least, amendments are made to the registers of UO and CA. Note that the procedure only builds a table of rows, and does not include it (cell 272 does not move).

Procedure 110550. Used by the previous procedure to build a continuous section of the row table. Called through JSR R5 and contains 4 parameters located in 4 words after the command.

The 1st parameter is the starting address at WHO.

The 2nd parameter is the starting address in the row table.

3rd parameter - the number of elements.

The 4th parameter is a step at WHO.

As a result, a table will be built in the RAM RAM in which the addresses of the WHO will be written in constant increment through the word.

Procedure 110656. This subroutine rewrites their initial values ​​from the ROM (although it can also from RAM) to the on-screen cards, and then the UO and CA registers are written to the addresses indicated in the card. The procedure is called through JSR R5 and has 2 parameters.

1st parameter - starting address in ROM (RAM).

The 2nd parameter is the starting address of the screen map.

In ROM, each screen map is represented as follows:

1st word - the number of variables in EC. Next are these variables, and then 4 words - the contents of UO1, UO2, UTs1, UTs2.

Reumerate to §10.

• EMT 52 prints a character string to the top service line.

• EMT 56 - to the bottom information line.

• The address of the line is indicated in the word following the command. The first byte in the line is the X position (left).

• EMT 40 initializes the screen.

• Initialization Sequence:

1) erasing all 3 WHO plans;      

2) enable interrupts from receiver K0;      

3) building a row table;      

4) rewriting the character generator table from ROM;      

5) rewriting the table of special functions from ROM;      

6) initial installation of buffer pointers;      

7) rewriting screen cards from ROM;      

8) initial settings:      

- inclusion of a row table,         

- current screen - working,         

- turning on the cursor,         

- initial settings for the colors of the symbol and familiarity.         

-           

Chapter 4. Integrated graphics .         

Њл Ґ блгз © ® ўл¤ҐлЁЛё Ја дёЄг ў ®в¤Ґлмго Јл ўг. ‚Ёёв п ў П ‡“ “Љ, ®     

§ ¬¬ Ґв Ў®лҐҐ ®¤® © Їпв® © Ї®бв®п® © Ї ¬пвЁ ¬ иёЛ ё ўлЇ®лпҐв ўҐбм¬     

Ї®лҐ§лҐ ўҐйЁ.

, Bva®Ґ n Јa dOЄ Ї®§ў®lpҐv ўlЇ®lpvm blҐ¤goyOҐ dgЄzhOO:   

• aOb®ў OҐ v®ЄO § ¤ l¬ zhўҐv®¬,   
• aOb®ў OҐ ®vaҐ§Є § ¤ l¬ zhўҐv®¬,    
• aOb®ў OҐ Їap¬®gЈ®lmOЄ § ¤ l¬ zhўҐv®¬,    
• § Ї®lҐёҐ Є®vga § ¤ л¬жўҐв®¬,    
• filling the area with the specified color.

Graphics procedures can be called both from the side of the CPU (on channel K0), and

by the PP (direct appeal to the procedures). That is, we can say that

Graphics can be called in both standard and non-standard ways.

Both of these methods are described in detail in this chapter. Let's start with the standard one.

§eleven. Standard reference to the schedule.

11.0 Graphic mode and its inclusion.

So, we work either with channel K0 from the CPU or with a buffer from the PP. Working with graphics comes down to sending commands (codes) to the terminal. These commands are accepted by the graphics management program, and that, in turn, starts the necessary procedures with the necessary parameters.

In general, the terminal UK-NC has two modes - symbolic and graphic. The first is discussed in the chapter "Standard screen output" and includes the display of characters on the screen and the launch of special functions.

The second - graphic - is enabled by the special function 45 (%). After its inclusion, the codes sent to the terminal are analyzed in a special way and are no longer related to the screen output program. They are processed by the graphics management program. It starts with a sequence of codes:

  character: <33>%! 0

     Code: 33 45 41 60.

This is the inclusion of graphics mode.

The first two codes call SF-45, the third (!) Is set here, apparently for the greater seriousness, and the fourth (0) means that the graphics management program is called.

In general, the last code can be any, and only 2 low-order bits are taken into account. If they are zero - this is a graphic, then the cursor turns off and our program is called. If they are nonzero (the lowest digit of the code is 1,2,3 or 5,6,7), the SF-27 is simply called, which, as you know, includes the N1 command system. All this can be traced according to the block diagram of the SF-45 (scheme 11.0)

The coordinate system of the graphic mode is standard: the point (0,0) is the lower left corner of the screen.

11.1 Graphics mode operations.

After the graphic mode has been enabled, the program expects the arrival of sequences of codes that will be interpreted as graphic commands.

The general format of these packages is as follows:

    <33> <Command> <Litera> [Parameters].

    Here <Command> and <Litera> are codes representing this or that operation, and [Parameters] is a sequence of bytes in a special format, which can mean color or coordinates. Depending on the operation, the number of byte parameters can be different - from zero to 13.

This form of invoking operations (after 33) is similar to invoking special functions. However, we note again that graphic commands do not apply to special functions.

In the future, the operation of the graphics management program and the format for representing the parameters will be described in detail, but for now, we summarize the call to graphic operations in table 11.1. You can see that, as a rule, several letters correspond to each team.

    Table 11.1 Call of operations of the graphic mode.

11.2 Data presentation formats.

In table 11.1 in the column "Parameters" in angle brackets the data

transmitted through the buffer. This data can mean either one number (color),

or a pair of numbers (coordinates).

                  Number in ATSE format.

A 16-bit number in this format is converted to 3 bytes. It's done

in the following way:

1) a 16-bit word is divided into 3 parts - two 6-bit and one 4-bit;

     <Here is a partitioning scheme>.

2) each part is supplemented with up to 8 bits by a mandatory prefix, and the third part

- also familiar.

     <Here is also a diagram>.

As a result, we have 3 bytes ready to send.

                  A pair of coordinates in the ACE format.

In this case, two 12-bit numbers are represented as 5 bytes. Strategy that

But - each number is divided into parts, and then we compose these parts together with

prefixes:

1) <Here is a partition scheme>;

2) <And here is the layout diagram>.

The result is 5 bytes, in which, if desired, you can see a couple of coordinates.

Such a fun presentation of data seems to have been introduced for compatibility with

earlier versions of the terminal command system. For graphics of UK-NTs these

the conversion didn’t work: in order to start the operation with

parameters from the CPU, you must first encrypt the data in the AEC code, and then

The software decrypts them in the usual format and distributes them into variable cells (already

in normal form). Of course, this is a long time.

Further, in the next paragraph, we will show where in the RAM RAM the graphic

variables and how to directly call graphically procedures.

Now lovers of digging into the bowels of the car can see how it works

graphics management program. Others boldly scroll to §12.

11.3 Operation of the control program.

So, the action of the SF-14 led to the fact that after turning off the cursor (CALL 111632)

The graphics management program (CALL 135436) was called up. Figure 11.3

The core of this program is presented.

When launched, the program saves R5 on the stack and assigns R5 a value

stack counter. Then comes the call to the director of the initial table (CALL 136274), and

upon leaving it, R0 is analyzed. If its value is 0, occurs

exit from the control program (with restoration of R5 and SP), otherwise

In the event, the director is restarted.

What is the director of the initial table? Recall that all managers

graphic sequences begin with code 33. The director, having accepted this code,

runs the director of teams. That, in turn, analyzes the second

incoming code, etc.

In general, the work of directors boils down to the following. In a special table

(for example, in the initial table or in the command table) codes and addresses are stored,

corresponding to these codes. Everything is very simple: the director, finding the code in the table,

equal to the incoming, sent to the appropriate address. If

there is no such code in the table, there is a transition to the address where just R0 is assigned

1 and there is a return to the previous director.

There are 3 "layers" of directors.

The first is the top one, this is the director of the initial table, it recognizes code 33 and

runs the director of teams.

The second layer consists of one team director. This parses the command

(2nd incoming code) and runs the letter directors.

The third layer is 6 letter directors. Each team has its own

letter director. It distributes control already directly to

depending on the letter (3rd code).

Block 11.3 shows the block diagrams of letter directors. They are all identical, beyond

the exception of one digit is the address of the letter table with which these directors

work. Letter tables are shown right there.

            Summary to §11.

* The terminal of the Criminal Code has two modes - symbolic and graphic.

* The peculiarity of the graphic mode is that the codes sent to the terminal,

analyzed in a special way, and neither to symbols, nor to special functions of the relation

Dont Have.

* Graphic mode is activated by a sequence of codes:

        <33>%! 0.

* Graphics mode operations are invoked by code sequences. Each

the sequence consists of 3 bytes and parameters:

      1st byte - 33

      2nd byte - command code

      3rd byte - letter code.

   Some operations have no parameters.

* Each operation is uniquely determined by the team and the letter.

* Parameters of graphic operations can be signed numbers, meaning

color, as well as a pair of coordinates - (X, Y).

* These parameters are transmitted to K0 (and to the buffer) in encoded form. Number

converts to 3 bytes, and a pair of coordinates to 5 bytes.

* The graphics management program is engaged in the analysis of command and character codes,

which associates with each allowed combination of codes the address and

sent to him.

  This starts the graphical operation.

§12. Work graphic operations.

12.0 Unnecessary operations.

We settled on the fact that the "correct" combination of command codes and letters

inexorably causes surgery. The operations in table 11.1 can

add a few more that have no practical use, that is, nothing

not doing.

This is: RU,

              RD

              UE

              U D.

Although the control program responds to them, they are all empty.

There are 2 more operations, the meaning of which is not completely clear:

              MM

              M V.

Now we will consider all existing operations in order. Figure 12.1

their action is shown.

12.1 Operation of standard operations.

  LI ................ Setting character mode colors

  The starting address is 136414.

  Parameters: <Tss> <Ts> <Tse> (color of the character, familiarity and screen).

  Act. In the current screen map, writes the colors of the symbol, familiarity and

screen. The colors of the symbol and familiarity are written in RT and the Russian Federation, respectively.

  Job. Using routine 143756, the number from the ADC format is converted to

normal format and is written to the cell (23424). From there, the color corresponds

to the appropriate cell. This is repeated 3 times, each time with a new color.

Colors are written to cells:

    (23456) - symbol color,

    (23460) - the color of familiarity,

    (23462) - screen color.

The contents of these cells are pushed onto the stack, procedure 117026 is called.

the colors from the stack are copied to the screen map and to cells (71 60), (7162),

(7164), and then in the RT and the Russian Federation. Upon exit from the procedure, the stack is restored and

there is a standard exit from the operation:

        R0 = 1,

        JMP 136046.

  ML ................. Sets the color for the line.

Starting address: 136442.

Parameter: <Cn> (color for line and point).

Act. In cell (23442) the color of the line is copied.

Job. Procedure 143756 is used to convert to normal format.

  MM ................ Setting the color of something.

Starting address: 136562.

Parameter: <C>.

Act. A number is written in cell (23446) (color, probably).

Job. Similar to M L.

  MP ................ Set the fill color.

Starting address: 136602.

Parameter: <Цf>.

Act. The fill color (negative number) is written in cell (23450)

0 ...- 7 in the additional code).

Job. Similar to M L.

  RD ................ Empty operation.

  RU ................ No less empty operation.

  RR .............. Filling a rectangular area.

Starting address: 136706.

Parameters: <X1Y1> <X2Y2> <Cb>.

Act. Draws a rectangle filled with color Tsb with coordinates

diagonals (X1, Y1) - (X2, Y2).

Job. Procedure 144104 converts the first coordinate pair (X1, Y1) to normal

format and writes them to cells (23420) and (23422):

     X -> (23420),

     Y -> (23422),

Then these values ​​are compared with the maximum allowed:

     Xmax = (23412),

     Ymax = (22664),

and, if less than them, then the second pair of coordinates is taken and converted to normal

format. Their values ​​are also checked, and if they do not go beyond the set

limits, color is read and converted to normal view. Resulting 5

words:

         Cb, Y2, X2, Y1, X1

pushed onto the stack. Procedure 144666 is being performed, which, in fact,

draws a rectangle.

  TD .............. Sets the color of the cursor.

Starting address: 137122.

Parameters: <C1> <C2>.

Act. Sets the color of the cursor on the home screen.

Job. The first color is accepted by the procedure 143756 in the cell (23452), then

the second - it is written in the cell (23454). The first byte through the stack is passed to

procedure 117004, where 4 low bits are allocated from it. They are written in the cell.

(7166), as well as in the EC of the working screen - in the cell (22742). Second color nowhere

not written, he sits in (23454). Everything ends traditionally - R0 = 1,

JMP 136046.

  UA ................. Read point color.

Starting address: 137222.

Parameters: none.

Act. The color of the current point is sent by K0 in the AEC format. The package

ends with code 15 (vk).

Job. RA - (177010) is loaded from the variable (23430), which contains

address of the current point in WHO. Read RO (177024), while the Russian Federation -

(177020) ... (177022) - loaded with the contents of plans at this address. Then

the position of the point in the octet is checked (23440), and, depending on which

half an octet rests the starting point, R0 is loaded either first (177020),

or the second (177022) word of the Russian Federation. Further after some tricky manipulations

the color of the current point is still on the stack, and with the help of procedure 144304 it

sent to the channel in a very encrypted form. Then sent to the channel

code 15, the operation ends successfully.

  UB ................... Fill the circuit.

Starting address: 137334.

Parameters: none.

Act. Starting from the current point (and its coordinates are stored in a pair of cells:

          Xtec = (23414),

          Ytek = (23416)),

filling begins with the color CF (cell (23450)) of the screen. Dots with color cp

(cell (23442)) cannot be filled. And since the filling is carried out

sequentially, point by point, then a closed loop drawn in color

direct, will be filled from the inside (if the current point is inside it) or

will be "surrounded" by the color CF outside (if the point is outside).

Job. Cells (23414) and (23416) - X and Y - are interchanged, then called

procedure 151714, at the output of X and Y, they are restored to their original values.

Procedure 151714 does the following. Registers are written to the stack (CALL 147662),

initial settings of variables are made (CALL 151756), the mode is set

filling ((23634) = 0), the filling procedure itself starts (CALL 145624),

then the variables (CALL 176300) and the registers (CALL 147706) are restored.

  UC .............. Filling the area.

Starting address: 137334.

Parameters: none.

Act. The function is mirror operation "U B" (literally and figuratively).

Firstly, this operation repaints the area painted by the color of the CPU in the color

Cf (and "U B" does the opposite - does not touch the points with the color of the CPU). Secondly,

the coordinates of the current point are interchanged: X is Y, and Y is X. Other

in words, from a point with coordinates (Y, X) there is a repainting of the points,

communicating with the current, painted in CPU.

Job. Similar to "U B", but cells (23414) and (23416) do not swap

(hence mirroring), and cell (23634) is set to 177777 (mode

repainting). The "root" procedure is the same - 145624.

  UD ...................... An empty operation.

  UE ...................... An empty operation.

  UF ................... Setting the coordinates of the current point.

Starting address: 137442.

Parameters: <XY>.

Job. Using procedure 144104, a coordinate pair is converted to

digestible look:

          X = (23420),

          Y = (23422).

Then they are checked for falling into the dimensions of the screen, and, if everything is in order,

necessary manipulations with graphic variables are performed.

The meaning of the variables used here is as follows:

      (23414) - X current,

      (23416) - Y current,

      (23420) - X required

      (23422) - Y required

      (23426) - octet position in the line (X / 8),

      (23430) - current address of the WHO,

      (23432) - address of the bottom video line in the row table,

      (23434) - address of the current video line in the row table,

      (23436) - octet,

      (23440) - the position of the point in the octet (0 ... 7).

  UG ................. Drawing a line.

Starting address: 137620.

Parameters: <XY>.

Act. Draws a line segment from the current point to the specified parameters.

Color - CPU. Point (X, Y) becomes current.

Job. After receiving the coordinates and checking them, the first point is set, and then

the entire remaining segment is drawn (CALL 141330).

  UH ................. Drawing a point.

Starting address: 137722.

Parameters: <XY>.

Act. Draws a point in the color of the CPU with the given coordinates. This point

becomes current.

Job. Similar to the work of "U F", but at the end the point is still set:

  RT load: (177016) = (23422),

  Loading RA: (177010) = (23430),

  Loading Russian Federation: (177024)

                       (177010) = (23430),

  Octet overlay: (177024) = (23436).

  UI ................... Reading coordinates.

Starting address: 140140.

Parameters: none.

Act. Sends to the channel the coordinates of the current point in the AEC format. The package

ends with code 15 (VK).

Job. The contents of cells (23416) and (23414) are sent to the stack;

procedure 144454, which encodes the coordinates and sends them to the channel, then

code 15 goes on the stack and is also sent to the channel.

  %! ................... Mode.

Starting address: 140232.

Parameters: N mode (1 byte).

Act. The byte following the letter is analyzed. If it is 60, nothing

Interesting does not happen (the graphic mode remains). Otherwise, there is a switch

to the mode indicated in the two least significant bits. If they are not zero, there is a return to

character mode.

Job. See "Action".

12.2 Direct control of graphic procedures.

The bulkiness of a standard graphics call slows down and complicates

graphic programs. However, for managing graphics from the PP there is a good

opportunity - write parameters directly to cells, and call

necessary procedures also directly. Here we will tell you how convenient

just do it.

            Graphic variables.

1. The coordinates.

Coordinates are set in the usual format, i.e. one number corresponds to a word,

a pair of coordinates - 2 words.

A pair of cells contains the current coordinates:

Xtec = (23414)

Ytek = (23416).

It is these coordinates that are read into the channel when reading through the operation "U I".

two more cells contain the specified (required) coordinates:

Xtr = (23420)

Ytr = (23422).

The difference between these coordinates is as follows. Current change graphic

procedures in the process of their work (from the inside), and the required ones change only from the outside,

when setting coordinates for procedures.

Another pair of cells is used for maximum values:

Xmax = (23412)

Ymax = (22664).

Note that cell (22664) is from the on-screen map of the home screen. She means

the number of video lines on the home screen.

2. Colors.

To set the color, there are two cells:

The color of the line and point: Cp = (23442).

Fill color: Cf = (23450).

Cf has a negative sign: color 7 corresponds to number 177771, and 0

matches 0.

These variables are used by point and line drawing procedures, as well as

filling the contour and area. The procedure for filling the rectangle is not

uses these cells, the color of the rectangle is set on the stack.

Three cells - (23444), (23446) and (23454), defined by the operations "M V", "M M" and

"T D", respectively, are not used by graphics procedures. You can with clean

conscience to use them in your own procedures.

3. Other variables.

Graphic procedures use several cells to fit your needs:

(23426) - position of the current octet in the video line,

(23430) - current address at WHO,

(23432) - address of the bottom video line in the vehicle,

(23434) - address of the current video line in the vehicle,

(23436) - octet,

(23440) - the position of the point in the octet (0 ... 7).

Another cell - (23424) is used for converted from the ATSE format

number.

You are welcome to use these variables to your needs!

       Graphics in various screens.

The graphics are not related to screen cards, so operations will not work

only in the current screen. Changing the screens is quite simple: enough

change the value of the cell (23432), which means the address in the table of rows of

line, which is taken as the bottom (Y = 0).

The values ​​for this cell for the four standard screens are shown in Table 12.2.

Table 12.2 Cell contents (23432) for working in standard screens.

  Screen (23432)

  Service line 2460

  Home screen 4534

  Service screen 6604

  Info line 7024

Nominal value (default) - 4534 - working screen.

           Direct call of graphic procedures.

We went directly to the graphical procedures, thereby useful

routines.

Their call, the transmitted parameters, as well as the actions are shown in table 12.3.

Table 12.3 Reference to graphical procedures.

     <Here is the table!>

Such a "strange" call to procedures such as for a point, for example,

due to the fact that some of them do not exit immediately through RETURN,

but use the "stub" with the address 136046.

                   Summary to §12.

• Allowed combinations of commands and characters, i.e. operations - 19. Of these, 4 are empty, i.e. do not perform any beneficial actions. 2 more operations are not needed for the graphics of the Criminal Code. Total remains 13 useful operations.

• Of these, 5 work with the screen: draw points, segments, rectangles,

- paint over and fill the area.         

• The rest perform auxiliary tasks: they record and read coordinates and colors, and one allows you to exit the graphic mode.

• For programs running in RAM RAM, calling graphic procedures can be greatly simplified:

- write coordinates and colors directly to cells - variable graphics and         

- call graphic procedures directly (via CALL).         

• You can use graphics on any screen. To change the screen in which all standard graphic procedures will work, it is enough to change the contents of only one cell - (23432).

Chapter 5. Using the network timer .        

             † l®Ўl   рё§m ...  

   Пёб вм ЄЁЈг - § пвЁҐ зҐав®ўбЄЁ бл®р®Ґ. Пёб вм ЄЁЈг ®Ў “Љ-ЌЦ -   

ў¤ў® © Ґ. ˆ ў®in Ї®zҐ¬g.

   â,¬ §®Ўa vmbp ¢ and Ў®vҐ § Їgv le Їa®Јa ¬¬ ¢ E det eOva®bЇlҐvҐOpe,      

ўл¤ ўлёў п §§ П З “л®ЈЁЈг ё §¤а ўл © б¬лбл Ї® Є ЇлҐ, ё Ґ¬Ґп Ї®¤ ¤ЄЄ ©    

Lёm “Љ-ЌЦ, ¤Ё§ бᥬЎлҐа, aggЄg Ё Ўг¬ Јг, - нв® ў®-ЇҐаўле.  

   Все Explain everything found, so that in the written could

understand not only the author, but also some readers, and without 

loss of mental health by both sides - this is the second.

   All together at times it grows into a global problem - "And you need

is it ?! ". And only the innate irrationality of the will, referred to among the people 

obstinacy, moves the author to continue work.

                              * * *

   In this chapter, we will deal with the network timer PP, more precisely with 

/ pa - - RX @ AKG \ @A] C + WpMQEA_ + KR \   

Chapter 6. Multiscreen output     

   Now that we’ve taken apart the main aspects of the screen output, 

to summarize by putting everything together in practical recommendations. These

recommendations carry a minimum of new and maximum useful. Respectively,

minimum theory and maximum practice.

§sixteen. Multiscreen output.

16.0 Change the current screen.

   By changing the current screen, we understand such actions, after 

which screen output will work in the desired screen predictably

and no problem.

   First of all, you need to make the desired screen visible (for example,

changing the working screen to the service one). Work goes, of course, on the table

lines.

   Here everything revolves around cell (2476), which contains the address 

continuation of the row table, i.e. screen that we will include in the window 

between information lines.

   This address for the service screen is unique:

• The service screen in the window: (2476) = 4672.

   For the working screen, there is no such unambiguity. The reason is 

that the roll can work in the working screen, and the cell value (2476)

changes when scrolling the screen.

   Therefore, before changing the working screen to the service one, it is necessary 

save cell value (2476). Then, upon return, it follows 

restore.

   As for the upper and lower information lines, the table 

lines do not need to be changed here, because these lines are always present on 

terminal.

• So, to change the working screen in the window to the service one without 

      problems with returning back:

             1. Save the cell value (2476).

             2. Record in number (2476) the number 4672.

             3. When returning, restore the old value of the cell.

   Now, in order to provide output to this screen, you need to change 

screen map, writing in the cell (23150) its starting address:

             Screen (23150)   

       Worker 22656

       Office 22754

       Bottom info line 22560

       Upper info line 23052

   However, if we need a cursor in a new screen, we must do 

some more activities. Namely:

       - change the contents of the cell (23160) - address of the highest byte of UO1;

       - update the tracking cell from the EC with the cursor - (23164). And further

          it is necessary to write the cursor color in UO1 (again from EC).

   All these actions will be done for us by the final part of EMT 40. 

(if you ask her well). The request should be as follows: in R5 we write the address 

the screen map that we make current, and call 

subroutine from the address 110210. She will do everything in the best possible way, including

number will write the address of the EC in the cell (23150) and load the colors from the EC 

points and background in RT and RF:

• Actions to transfer screen output to the desired screen:

                 MOV #A, R5

                 CALL 110210

        #A is the address of the beginning of the screen map that we make current.

   When transferring screen output to info lines, please note that in 

their screen maps the cursor is off:

        (R5 + 72) = 0, i.e. tracking turned off;

        (R5 + 70) = 0, i.e. cursor color - 0.

   If in these screens we need a full cursor, then, before 

in order to call procedure 110210, you need to enable tracking and 

set an acceptable cursor color (e.g. 7):

        MOV # 2, 72 (R5)

        MOV # 7, 70 (R5).

16.1 Build your screen.

   In case you are not satisfied with the standard screens of the Criminal Code, you can 

develop your own. Development is carried out at several levels:

        - screen map (EC),

        - table of rows (TS),

        - video RAM (WHO).

   In fig. 16.1 shows a figurative diagram of the operation of the screen output. 

Screen output program and special functions through the screen card work     

with WHO (video information) and with vehicle (display of video information on 

terminal). 

        <Fig. 16.1 On-screen output {77}>

   Replaceable parts are EC, TS and WHO. In other words, it is necessary 

take care:

    - about the structure of the screen and its place on the terminal (in the TS);

    - on the placement of video information (allocate space in RAM);

    - All this must be summarized in a screen map.

          Placement of video information.

   Standard screens use 3 shared memory plans under video RAM 

96 Kb And all 96 Kb are actively used by the System - 

there is practically no free space in the plans (see Fig. 16.2 and 

tab. 16.0).

    Table 16.0 Addresses occupied by screens at WHO.

      WHO Address Screen

                          initial end   

    worker 100000      154537

    official 154540 175677

    upper I.-.s. 175700 176567

    lower and.-s. 176570 177457

    auxiliary 177460 177777

     the elements           

     <Fig. 16.2 Screens in the video memory. {78}>

   For new screens, either plans should be used, and thus 

disable some standard screens, or under WHO 

Use RAM CPU + RAM RAM. In this case, work with this 

video information will be possible directly. However standard programs

output work with video memory only using register access.

So by simply lowering the WHOU down you, alas, will not be able to increase

standard output speed.

   Nevertheless, in this way you can use part of the RAM, in many

cases not needed:

        * part of the RAM of the CPU (free from programs);

        * System RAM CPU (8 Kb); 

        * part of the system RAM RAM (not more than 22 Kb).

Recall that the RAM of the CPU corresponds to the 1st and 2nd plans of WHO, RAM RAM

- 0-th plan (Fig. 1.2).

   If, for example, you use 10 kilobytes of RAM RAM under the WHO (plan 0) 

+ 20 Kb of CPU RAM, including RAM (plans 1 and 2), you can 

implement a screen of 24 character strings in 40 familiarity mode 

line, which is quite good and quite enough for most 

programs.

   Some possible combinations of screen sizes we presented in 

table 16.1.

    Table 16.1 Possible amount of video memory for various 

                                    screen sizes (Kb).

    Number Number of familiarity per line                         

    symbolic        

      lines 10 20 40 80    

       1 0.32 0.64 1.29 2.58

      10 3.22 6.44 12.89 25.78

      20 6.44 12.89 25.78 51.56

      24 7.73 15.47 30.94 61.88

      26 8.38 16.76 33.52 67.00

      48 15.47 30.94 61.88 123.75 

   All this is true for 3-panel screens. But if you use 

"stratification" of screens, you can increase their size by 3 times with the same 

the amount of memory. But more on that later.

   If you use the system RAM of the CPU under the WHO (addresses 160000 and

above), preferably when exiting the program to restore the RAM (it 

contents). This is done using routine 173252. It is just 

rewrites about 5.5 Kb from ROM to CPU RAM.

• After using CPU RAM for your needs 

        restore the programs usually written there 

             (monitor, etc.):

              CALL 173252

   Using RAM as a video memory, try not to allow

a program of situations leading to the transfer of the CPU to HALT mode. Otherwise 

an interrupt will occur whose vector is at 160170, and 

its contents may be unpredictable if it is part of

Whoo.

                Organizing a row table.

   Now let's quickly remember why we need a table of rows. And I need                  

it in order to display information in the who 

sequence (line by line). In other words, TS is a bridge 

between the video information at WHO and the video image on the screen.

   We describe the standard row table in table 16.2 and in fig. 16.3.

    Table 16.2 Standard row table.

    N Addresses in the vehicle. Addresses in the WHO. Place on the screen N video

  e-string

  1 ... 18 270 ... 272, --- 18 empty elements ---

            2270 ... 2366 com. Inappropriate

                                           steal video lines

    19 2370 ... 2376 --- UO top info ---

                                           strings. Also not

                                           matches video

                                           line.

    20 2400 ... 2406 --- UC upper info ---

                                           strings. Also empty

                                           element in the sense

                                           WHO addresses.              

  21 ... 30 2410 ... 2456 175700 ... 176450 Upper 1 ... 10

                          (step 50) info line   

    31 2460 ... 2466 176520 End of upper 11

                                           info lines 

                                           UO of the working screen.                          

    32 2470 ... 2476 177460 Upper divider - 12

                                           video line

                                           CA home screen        

  33 ... 318 2500 ... 4666 100000 ... 154420 Operating screen 13 ... 276

                          (step 120)

    319 4670 ... 4676 177460 Start of the top 13

                                           rims

                                           UO official 

                                           screen                      

    320 4700 ... 4706 177460 Start of the top 14

                                           rims

                                           CA service 

                                           screen

  321..340 4710 ... 5026 177460 Upper border 15 ... 34

                                           service screen

                                           (2 empty characters

                                           ny lines)

  341..560 5030 ... 6606 154540 ... 175630 Service screen 35 ... 254

                          (step 50)            

  561..582 6610 ... 6736 177460 Lower border 255 ... 0 + Еp + ё + R - ++ Q + v + pPV-Е¶Wёёёu-Рp + VQWUЎЖЕВї-РпёпWUT¶РЕЕ

§17. How to diversify screen output.

17.0 Ways to Variety of Screen Output.

   In addition to creating your own screens, there are ways to change the work. 

screen output itself.