Last modified by Max on 2025/03/02 15:18

From version 2.14
edited by Max
on 2025/02/25 12:56
Change comment: (Autosaved)
To version 2.1483
edited by Max
on 2025/03/02 15:13
Change comment: (Autosaved)

Summary

Details

Page properties
Content
... ... @@ -382,46 +382,50 @@
382 382  Command code 013, the command reads the TOC record into the internal memory area and switches the pointer to it for data transfer via DR. The TOC must be open before this.
383 383  
384 384  The procedure is as follows:
385 -• Сбросить контроллер.
386 -• Выдать в CSR команду "Прочитать запись оглавления" и дождаться ее окончания.
387 -• Выдать в CSR команду "Прочитать из памяти контроллера"
388 -• Прочитать из DR 11 слов записи оглавления
389 -\\Запись оглавления имеет формат:
390 -\\См. Имя Значение
391 -0 fSize Размер файла в байтах, младшее слово
392 -2 старшее слово
393 -4 fDate Дата в формате MS-DOS
394 -6 fTime Время в формате MS-DOS
395 -10 fAttr Атрибуты 1 байт
396 -11 fName ИМЯ.ТИП файла, 8+1+3+1 = 13 байт
397 -\\Смещения указаны восьмеричные. Формула в строке fName означает, что там сначала должно быть имя, максимально из восьми символов, далее должна быть точка, далее тип, до трёх символов, и завершающий нулевой байт 0х00. Если тип не указан, точка тоже не нужна.
398 -\\Атрибуты файлов в байте fAttr (восьмеричные):
385 +• Reset the controller.
386 +• Issue the command "Read the table of contents entry" to the CSR and wait for it to finish.
387 +• Issue the command "Read from controller memory" to the CSR
388 +• Read 11 words of the table of contents entry from DR
389 +\\The table of contents entry has the format:
390 +
391 +(% style="width:686px" %)
392 +|=(% style="width: 136px;" %)Offset (octal)|=(% style="width: 305px;" %)Name|=(% style="width: 242px;" %)Value
393 +|(% style="width:136px" %)0|(% style="width:305px" %)fSize|(% style="width:242px" %)File size in bytes, low word
394 +|(% style="width:136px" %)2|(% style="width:305px" %)fSize|(% style="width:242px" %)File size in bytes, high word
395 +|(% style="width:136px" %)4|(% style="width:305px" %)fDate|(% style="width:242px" %)Date in MS-DOS format
396 +|(% style="width:136px" %)6|(% style="width:305px" %)fTime|(% style="width:242px" %)Time in MS-DOS format
397 +|(% style="width:136px" %)10|(% style="width:305px" %)fAttr|(% style="width:242px" %)Attributes 1 byte
398 +|(% style="width:136px" %)10|(% style="width:305px" %)fName|(% style="width:242px" %)NAME.FILE TYPE, 8+1+3+1 = 13 bytes
399 +
400 +
401 +The offsets are specified in octal. The formula in the fName line means that there must first be a name, maximum of eight characters, then a period, then a type, up to three characters, and a terminating zero byte 0x00. If the type is not specified, the period is also not needed.
402 +\\File attributes in fAttr byte (octal):
399 399  \\001 - Read Only
400 400  002 - Hidden
401 401  004 - System
402 402  020 - Directory
403 403  040 - Archive
404 -\\Пример программы.
408 +\\Example program
405 405  
406 406  {{code language="assembler"}}
407 407  ;......................................
408 -RdDir = 013; код команды "Читать запись оглавления"
412 +RdDir = 013; command code "Read table of contents entry"
409 409  RdBuf = 015
410 410  
411 411   MOV #AZ$CSR,R3
412 412  
413 413  15$: CLR @R3;
414 - TSTB @R3; Сбросим контроллер
418 + TSTB @R3; Reset the controller
415 415   BPL 15$;
416 416  
417 - MOV #RdDir,@R3; Попросим контроллер
418 -16$: TSTB @R3; прочитать в свою память
419 - BPL 16$; запись оглавления
421 + MOV #RdDir,@R3; Ask the controller
422 +16$: TSTB @R3; to read into its memory
423 + BPL 16$; table of contents entry
420 420  
421 421   MOV @RdBuf,(R3)+;
422 - MOV DIRREC,R2; И перенесем ее к себе в
423 - MOV #11.,R1; область памяти, указатель
424 -17$: MOV @R3,(R2)+; на которую лежит в ячейке
426 + MOV DIRREC,R2; And transfer it to itself in
427 + MOV #11.,R1; memory area, pointer
428 +17$: MOV @R3,(R2)+; to which lies in cell
425 425   SOB R1,17$; DIRREC.
426 426  
427 427  ;......................................
... ... @@ -428,96 +428,97 @@
428 428  {{/code}}
429 429  
430 430  
431 -== **014: Размонтировать диск** ==
435 +== 014: Unmount disk ==
432 432  
433 -Код команды 014, чтобы размонтировать диск, следует сбросить контроллер, переслать в DR контроллера номер привода AZ, который следует размонтировать, и послать в CSR контроллера код 014, после чего дождаться окончания операции (она длительная) и проверить на ошибку. Ошибка выдается, если привод не был смонтирован.
434 -[[**//пример утилиты AZUMNT//**>>url:https://forum.maxiol.com/index.php?showtopic=5605&st=0&p=59418&#entry59418]]
437 +Command code 014, to unmount the disk, you should reset the controller, send the AZ drive number to the controller DR, which should be unmounted, and send the 014 code to the controller CSR, then wait for the operation to complete (it takes a long time) and check for an error. An error is issued if the drive has not been mounted.
438 +[[AZUMNT utility example>>url:https://forum.maxiol.com/index.php?showtopic=5605&st=0&p=59418&#entry59418]]
435 435  
436 436  
437 -== **015: Начать передачу считанного блока** ==
441 +== 015: Start transferring the read block ==
438 438  
439 -Код команды - 015. Получив эту команду, контроллер настраивается на пословную выдачу содержимого того самого встроенного буфера на 256 слов, которые будут выданы последовательно через регистр DR. Никаких ожиданий не требуется, просто пересылаем 256 раз слово из DR в последовательные ячейки памяти, и все. Если нужно меньше, чем 256 слов (последний укороченный блок файла), то остаток можно просто бросить, не считывая, сброс контроллера в начале следующей операции сбросит и этот остаток.
440 -\\Пример программы:
443 +The command code is 015. Having received this command, the controller is configured to output word by word the contents of the same built-in buffer for 256 words, which will be output sequentially through the DR register. No waiting is required, we simply send a word from DR to sequential memory cells 256 times, and that's it. If less than 256 words are needed (the last shortened block of the file), then the remainder can simply be discarded without reading, resetting the controller at the beginning of the next operation will also reset this remainder.
444 +\\Example program:
441 441  
442 442  {{code language="assembler"}}
443 443  ;..................................
444 -RdBuf=015; символическое наименование команды
448 +RdBuf=015; symbolic name of the command
445 445  
446 -; В R3 от предыдущего фрагмента остался адрес CSR
450 +; In R3 from the previous fragment there is the address of the CSR
447 447  ; (177220)
448 448  
449 -; Считаем, что у нас в R2 находится адрес первого слова
450 -; памяти, куда следует разместить прочитанный блок.
451 -; Программа получения этого адреса не приводится.
453 +; We assume that in R2 we have the address of the first word
454 +; of memory, where the read block should be placed.
455 +; The program for obtaining this address is not given.
452 452  
453 - MOV #400,R1; Готовим счетчик слов
457 + MOV #400,R1; Prepare the word counter
454 454   ; 0400 oct = 256 dec
455 455  
456 - MOV #RdBuf,(R3)+; и пересылаем команду
457 -; RdBuf в CSR. Адрес в R3 укажет на DR (177222).
460 + MOV #RdBuf,(R3)+; and send the command
461 +; RdBuf to the CSR. The address in R3 will point to DR (177222).
458 458  
459 -3$: MOV @R3,(R2)+;перешлем очередное слово в
460 - ; память
461 - SOB R1,3$; и повторим это 256 (0400)
462 - ; раз
463 +3$: MOV @R3,(R2)+we will send the next word to
464 +; memory
465 + SOB R1,3$; and repeat this 256 (0400)
466 + ; times
463 463  ;..................................
464 464  {{/code}}
465 465  
466 -Всё, чтение закончено.
467 -\\Для записи наоборот, требуется сначала перенести весь блок данных из памяти ЦП в контроллер и потом выдать команду "Записать содержимое буфера на диск"
470 +That's it, reading is complete.
468 468  
472 +To write the opposite way, you first need to transfer the entire data block from the CPU memory to the controller and then issue the command "Write the contents of the buffer to disk"
469 469  
470 -== **016: Принять блок данных в буфер** ==
471 471  
472 -Код команды 016. Команда настраивает контроллер на прием блока данных и помещении его в буфер. Следующие 256 циклов записи в DR поместят данные, переданные через МПИ, в буфер.
473 -\\Пример программы.
475 +== 016: Receive data block into buffer ==
474 474  
477 +Command code 016. The command sets the controller to receive a block of data and place it in the buffer. The next 256 write cycles to DR will place the data transferred via the QBUS in the buffer.
478 +\\Example program:
479 +
475 475  {{code language="assembler"}}
476 476  ;..................................
477 477  
478 -WrBuf=016; Символическое наименование команды
483 +WrBuf=016; Symbolic name of the command
479 479  
480 -; Перед записью нужно выполнить те же действия, что и в
481 -; пп. 3.1.-3.3. Обычно, это одна и та же программа,
482 -; просто после пункта 3.3. выполняется проверка "Что
483 -; требуется: чтение или запись?" и разветвление на
484 -; программу чтения или записи.
485 +; Before writing, you need to perform the same actions as in
486 +; pp. 3.1.-3.3. Usually, this is the same program,
487 +; just after point 3.3. a check is performed "What
488 +; is required: reading or writing?" and a branch is made to the
489 +; reading or writing program.
485 485  
486 -; После фрагмента в п. 3.3. в R3 остался адрес CSR
487 -; (177220). Будем считать, что в R2 находится адрес в
488 -; памяти ЦП, где находится блок, подлежащий записи.
489 -; Программа получения этого адреса не показана.
491 +; After the fragment in point 3.3., the CSR address
492 +; (177220) remains in R3. We will assume that R2 contains the address in the CPU
493 +; memory where the block to be written is located.
494 +; The program for obtaining this address is not shown.
490 490  
491 - MOV #400,R1; Готовим счетчик
496 + MOV #400,R1; Preparing the counter
492 492  
493 - MOV #WrBuf,(R3)+; Перешлем команду в CSR и
494 - ; переключим адрес в R3 на
495 - ; DR
498 + MOV #WrBuf,(R3)+; Let's forward the command to the CSR and
499 +; switch the address in R3 to
500 +; DR
496 496  
497 -4$: MOV (R2)+,@R3; Перешлем очередное слово
498 - ; данных
499 - SOB R1,4$; и повторим это 256 раз
502 +4$: MOV (R2)+,@R3; Let's forward the next word
503 +; data
504 + SOB R1,4$; and repeat this 256 times
500 500  ;..................................
501 501  {{/code}}
502 502  
503 -== **017: Получить размер псевдодиска, большой** ==
508 +== 017: Get ramdisk size, large ==
504 504  
505 -Есть две команды получения размера псевдодиска, т.е. смонтированного на выбранный псевдопривод AZn файл-образа.
506 -\\Если используемая ОС (или программа, работающая с дисками без ОС) умеет работать с большими (больше 32М) дисками, следует пользоваться командой с кодом 017. Последовательность действий: сбросить контроллер (п. 3.1), выбрать накопитель (п. 3.2) и переслать в CSR код 017, а затем, без каких-либо ожиданий, считать из DR сначала младшее, и следом за ним старшее слово размера выбранного накопителя (файл-образа).
507 -\\Если используемая ОС не умеет работать с дисками бОльшими, чем 32М (RT-11), следует пользоваться командой 007 - получить размер псевдодиска с ограничением до 32М. Действия похожие: сбрасываем контроллер, выбираем диск, посылаем в CSR код [[007>>doc:||anchor="H007:41F43E43B44344743844244C44043043743C43544043F44143543243443E43443844143A430"]] и считываем из DR одно слово размера псевдодиска. Если размер файл-образа, смонтированного на выбранный псевдопривод, больше 65534 блоков, вместо этого "большого" размера, контроллер возвращает число 65534. Напоминаем, что число 65535 кое-где используется в специальных целях и не может быть размером диска.
508 -\\Также напоминаем, что если на этот накопитель не смонтирован файл-образ, последовательность действий не пройдет (команда 001 выбор устройства) и исполнение программы до этого места просто не дойдет. Поэтому ошибок у этих команд не предусмотрено.
509 -\\Пример программы с большими дисками
510 +There are two commands to get the size of a pseudo-disk, i.e. the AZn file-image mounted on the selected pseudo-drive.
511 +\\If the OS being used (or a program working with disks without an OS) can work with large (more than 32M) disks, you should use the command with the code 017. The sequence of actions: reset the controller (p. 3.1), select the drive (p. 3.2) and send the code 017 to the CSR, and then, without any waiting, read from DR first the lower word, and then the higher word of the size of the selected drive (image file).
512 +\\If the OS you are using cannot work with disks larger than 32M (RT-11), you should use the 007 command - get the pseudo-disk size with a limit of up to 32M. The steps are similar: reset the controller, select the disk, send the 007 code to the CSR and read one word of the pseudo-disk size from DR. If the size of the image file mounted on the selected pseudo-drive is larger than 65534 blocks, the controller returns the number 65534 instead of this "large" size. We remind you that the number 65535 is used in some places for special purposes and cannot be the disk size.
513 +\\We also remind you that if the image file is not mounted on this drive, the sequence of actions will not work (command 001 select device) and the program execution will simply not reach this point. Therefore, these commands do not provide for errors.
514 +\\Example of a program with large disks
510 510  
511 511  {{code language="assembler"}}
512 512  ;......................................
513 513  
514 -GetBig=017; Получить "большой" размер диска
519 +GetBig=017; Get the "big" disk size
515 515  
516 -; От фрагмента 3.2 (выбор диска) у нас в R3 остался
517 -; адрес DR (177222)
521 +; From fragment 3.2 (disk selection) we have in R3
522 +; DR address (177222)
518 518  
519 - MOV #GetBig,-(R3); пошлем команду
520 - TST (R3)+; вернем адрес в R3 назад, на DR
524 + MOV #GetBig,-(R3); send the command
525 + TST (R3)+; return the address in R3 back to DR
521 521   MOV @R3,BigSiz
522 522   MOV @R3,BigSiz+2
523 523  ;......................................
... ... @@ -524,27 +524,26 @@
524 524  {{/code}}
525 525  
526 526  
527 -== **020: Получить расширенный код диагностики** ==
532 +== 020: Get extended diagnostic code ==
528 528  
529 -Код команды 020, после сброса контроллера следует выдать эту команду в CSR и затем прочитать два слова расширенной диагностики из DR. Команда мгновенная, ожидание не требуется.
534 +Command code 020, after resetting the controller, you should issue this command in the CSR and then read two words of extended diagnostics from DR. The command is instant, no waiting is required.
530 530  
531 531  
532 -== **027: Получить версию firmware AZ STM32** ==
537 +== 027: Get firmware version AZ STM32 ==
533 533  
534 -Код команды 027, возвращает 2 слова
535 -\\первое слово - 06404 = старший байт 13. это версия прошивки, младший байт 4. это версия железа - те AZБК в данном случае
536 -второе слово - 037 = это максимальный монтируемый диск - 31.
539 +Command code 027, returns 2 words
540 +\\first word - 06404 = high byte 13. this is the firmware version, low byte 4. this is the hardware version - i.e. AZБК in this case second word - 037 = this is the maximum mountable disk - 31.
537 537  
538 538  
539 539  {{code language="assembler"}}
540 540  ;-------------------------------------------------------------
541 -; получение версии прошивки STM32 - результат в R1 R1=0 ошибка
545 +; getting STM32 firmware version - result in R1 R1=0 error
542 542  GTSTMV: MOV #AZ$CSR,R1
543 -1$: CLR (R1) ; Пошлем команду "Сброс"
544 - TSTB (R1) ; Проверим готовность контроллера
545 - BPL 1$ ; Если не готов, сбрасываем еще
547 +1$: CLR (R1) ; Send "Reset" command
548 + TSTB (R1) ;Check controller readinessконтроллера
549 + BPL 1$ ; If not ready, reset again
546 546   mov #27,(R1)
547 - TST (R1)+ ; Проверяем на ошибку
551 + TST (R1)+ ; Check for error
548 548   BMI 2$
549 549   mov (R1),R1
550 550   return
... ... @@ -554,45 +554,45 @@
554 554  {{/code}}
555 555  
556 556  
557 -== **030:  Нет операции** ==
561 +== 030: No operation ==
558 558  
559 -Основное назначение этой команды - устанавливать бит разрешения прерываний от контроллера. Команда передает бит разрешения прерывания, который находится с ней в одном слове, но не входит в ее состав (напоминаем, команда располагается в битах D0 - D5, а бит разрешения прерываний - D6), в соответствующий триггер контроллера и больше никак не влияет на процессы в контроллере. Управление этим триггером работает даже в состоянии "Думаю, прошу не мешать", и это главная особенность команды "нет операции".
560 -\\Команда имеет код 0030. Посылка в CSR кода 0130 разрешит прерывания от контроллера, посылка кода 0030 запретит их. Пример не приводится вследствие тривиальности его.
563 +The main purpose of this command is to set the interrupt enable bit from the controller. The command transfers the interrupt enable bit, which is in the same word with it, but is not part of it (remember, the command is located in bits D0 - D5, and the interrupt enable bit is D6), to the corresponding trigger of the controller and does not affect the processes in the controller in any other way. Control of this trigger works even in the "Thinking, please do not interfere" state, and this is the main feature of the "no operation" command.
564 +\\The command has the code 0030. Sending the code 0130 to the CSR will enable interrupts from the controller, sending the code 0030 will disable them. An example is not given due to its triviality.
561 561  
562 562  
563 -= **Блок команд работы с энергонезависимой памятью** =
567 += Command block for working with non-volatile memory =
564 564  
565 -Интерфейс предоставляет любому AZ-контроллеру доступ к 255 словам энергонезависимой памяти, все команды устанавливают бит готовности по завершению. Это позволяет сохранять пользовательские настройки в энергонезависимой памяти, к примеру это используется в AZБК - там сохраняются настройки для более комфортной работы контроллера.
569 +The interface provides any AZ controller with access to 255 words of non-volatile memory, all commands set the ready bit upon completion. This allows you to save user settings in non-volatile memory, for example, this is used in AZBK ??- there are saved settings for more comfortable operation of the controller.
566 566  
567 -Все команды этого блока используют буфер энергонезависимой памяти для своей работы.
571 +All commands in this block use a non-volatile memory buffer for their operation.
568 568  
569 -== **021: Cчитать блок энергонезависимой памяти в буфер** ==
573 +== 021: Read non-volatile memory block into buffer ==
570 570  
571 571  (% class="wikigeneratedid" %)
572 -Код команды 021, данная команда вызывает чтение блока энергонезависимой памяти в буфер энергонезависимой памяти.
576 +Command code 021, this command causes a block of non-volatile memory to be read into the non-volatile memory buffer.
573 573  
574 574  
575 -== **022: Отдать на шину считанный блок энергонезависимой памяти из буфера** ==
579 +== 022: Transfer the read block of non-volatile memory from the buffer to the bus ==
576 576  
577 577  (% class="wikigeneratedid" %)
578 -Код команды 022, данная команда обеспечивает передачу буфера энергонезависимой памяти в регистр DR для считывания.
582 +Command code 022, this command ensures that the non-volatile memory buffer is transferred to the DR register for reading.
579 579  
580 580  (% class="wikigeneratedid" %)
581 -Пример программы
585 +Example program
582 582  
583 583  {{code language="assembler"}}
584 -AZ$CSR = 177220; регистр команд и состояния (CSR)
585 -AZ$DR = 177222; регистр данных (DR)
588 +AZ$CSR = 177220; command and status register (CSR)
589 +AZ$DR = 177222; data register (DR)
586 586  
587 587  
588 -; trap 50 - cброс AZ
592 +; trap 50 - reset AZ
589 589  ; результат в R1 =0 ok
590 590  AZreset: MOV #AZ$CSR,R1
591 -1$: CLR (R1); Пошлем команду "Сброс"
592 - TSTB (R1); Проверим готовность контроллера
593 - BPL 1$; Если не готов, сбрасываем еще
594 - ; раз и проверяем снова
595 - TST (R1); Проверим на ошибку,
595 +1$: CLR (R1); Send the "Reset" command
596 + TSTB (R1); Check the controller readiness
597 + BPL 1$; If not ready, reset again
598 +; once and check again
599 + TST (R1); Check for an error,
596 596   BMI 0ERR$
597 597   CLR R1
598 598   return
... ... @@ -601,30 +601,30 @@
601 601   return
602 602  
603 603  
604 -; trap 54 - чтение энергонезависимой памяти блока 1 EEPROM в буфер с адреса ADREEPROMMEM
605 -; результат R3 - адрес, если R3=0 ошибка
606 -; статус чтения в R1 0 - ok
607 -; 1 - размер не соответствует сохраненному
608 -; 2 - oшибка версии
609 -; 3 - oшибка контрольной суммы
608 +; trap 54 - reading non-volatile memory of block 1 EEPROM to the buffer from the address ADREEPROMMEM
609 +; result R3 - address, if R3=0 error
610 +; read status in R1 0 - ok
611 +; 1 - size does not match saved
612 +; 2 - version error
613 +; 3 - checksum error
610 610  ReadEEPROM: push R2
611 - call AZreset; сбросим
615 + call AZreset; reset
612 612   tst R1
613 613   bne 0ERR$
614 614  ; теперь читаем
615 615   MOV #AZ$CSR,R1
616 - mov #21,(R1); считать блок 1 энергонезависимой памяти в буфер
617 -0$: TSTB (R1); проверяем результат выполнения
618 - BPL 0$; ждем
619 - mov #22,(R1); отдать на шину считанный блок энергонезависимой памяти из буфера
620 -1$: TSTB (R1); проверяем результат выполнения
621 - BPL 1$; ждем
622 - TST (R1)+; инкрементируем
620 + mov #21,(R1); read block 1 of non-volatile memory into buffer
621 +0$: TSTB (R1); check execution result
622 + BPL 0$; wait
623 + mov #22,(R1); send read block of non-volatile memory from buffer to bus
624 +1$: TSTB (R1); check execution result
625 + BPL 1$; wait
626 + TST (R1)+; increment
623 623   mov #ADREEPROMMEM,R3
624 - mov #256.,R2; читаем 256. слов; первое слово - результат чтения
625 -2$: mov (R1),(R3)+; читаем блок слов в память
628 + mov #256.,R2; read 256. words; first word is reading result
629 +2$: mov (R1),(R3)+; read block of words into memory
626 626   sob R2,2$
627 - mov #ADREEPROMMEM,R3; успешно
631 + mov #ADREEPROMMEM,R3; successful
628 628   mov (R3),R1
629 629   br 0END$
630 630  0ERR$: CLR R3
... ... @@ -632,41 +632,39 @@
632 632   return
633 633  {{/code}}
634 634  
635 -очевидно, после считывания памяти необходимо проверить код результата в первом слове - см расшифровку кодов ошибок
636 -\\Примеры возвращаемых данных по командам
637 -\\последовательная подача команды 021 и затем 022 позволит считать 256. слов
638 -из энергонезависимой памяти
639 -**Внимание! **первое слово это будет статус успешности чтения
640 -
639 +obviously, after reading the memory, it is necessary to check the result code in the first word - see the decoding of error codes
640 +\\Examples of returned data for commands
641 +\\sequentially issuing the command 021 and then 022 will allow reading 256 words from non-volatile memory
642 +Attention! The first word will be the reading success status
641 641  
642 642  * 0 - ok
643 -* 1 - размер не соответствует сохраненному
644 -* 2 - oшибка версии
645 -* 3 - oшибка контрольной суммы
645 +* 1 - size does not match saved
646 +* 2 - version error
647 +* 3 - checksum error
646 646  
647 -== **023: Принять с шины в буфер данные для последующей записи в буфер** ==
649 +== 023: Receive data from the bus into the buffer for subsequent writing into the buffer ==
648 648  
649 -Код команды 023, данная команда позволяет наполнить буфер энергонезависимой памяти
651 +Command code 023, this command allows you to fill the non-volatile memory buffer
650 650  
651 -== **024: Записать из буфера в блок энергонезависимой памяти** ==
653 +== 024: Write from buffer to non-volatile memory block ==
652 652  
653 -Код команды 024, данная команда вызывает запись блока энергонезависимой памяти из буфера энергонезависимой памяти.
655 +Command code 024, this command causes a non-volatile memory block to be written from the non-volatile memory buffer.
654 654  
655 -Пример программы
657 +Example program
656 656  
657 657  {{code language="assembler"}}
658 -AZ$CSR = 177220; регистр команд и состояния (CSR)
659 -AZ$DR = 177222; регистр данных (DR)
660 +AZ$CSR = 177220; Command and Status Register (CSR)
661 +AZ$DR = 177222; Data Register (DR)
660 660  
661 661  
662 -; trap 50 - cброс AZ
664 +; trap 50 - reset AZ
663 663  ; результат в R1 =0 ok
664 664  AZreset: MOV #AZ$CSR,R1
665 -1$: CLR (R1); Пошлем команду "Сброс"
666 - TSTB (R1); Проверим готовность контроллера
667 - BPL 1$; Если не готов, сбрасываем еще
668 - ; раз и проверяем снова
669 - TST (R1); Проверим на ошибку,
667 +1$: CLR (R1); Send the "Reset" command
668 + TSTB (R1); Check the controller readiness
669 + BPL 1$; If not ready, reset again
670 +; once and check again
671 + TST (R1); Check for an error,
670 670   BMI 0ERR$
671 671   CLR R1
672 672   return
... ... @@ -674,27 +674,27 @@
674 674   COM R1
675 675   return
676 676  
677 -; trap 55 - запись энергонезависимой памяти из буфера с адреса ADREEPROMMEM в блок 1 EEPROM
679 +; trap 55 - write non-volatile memory from the buffer at address ADREEPROMMEM в блок 1 EEPROM
678 678  WriteEEPROM: push R1
679 679   push R2
680 680   push R3
681 - call AZreset; сбросим
683 + call AZreset; reset
682 682   tst R1
683 683   bne 0ERR$
684 684  
685 685   MOV #AZ$CSR,R1
686 - mov #23,(R1); командуем что будем писать данные в буфер
687 -0$: TSTB (R1); проверяем результат выполнения
688 - BPL 0$; ждем
689 - TST (R1)+; инкрементируем
688 + mov #23,(R1);command that we will write data to the buffer
689 +0$: TSTB (R1); check the result of executio
690 + BPL 0$; wait
691 + TST (R1)+; increment
690 690   mov #ADREEPROMMEM+2,R3
691 - mov #255.,R2; пишем 255. слов; первое слово пропускаем - результат чтения
692 -1$: mov (R3)+,(R1); отдаем в контроллер
693 + mov #255.,R2; write 255. words; skip the first word - the result of reading
694 +1$: mov (R3)+,(R1); send to the controller
693 693   sob R2,1$
694 - tst -(R1); декрементируем
695 - mov #24,(R1); записать из буфера в блок 1 энергонезависимой памяти
696 -2$: TSTB (R1); проверяем результат выполнения
697 - BPL 2$; ждем
696 + tst -(R1); decrement
697 + mov #24,(R1); write from the buffer to block 1 of non-volatile memory
698 +2$: TSTB (R1); check the result of execution
699 + BPL 2$; we are waiting
698 698   br 0END$
699 699  0ERR$: CLR R3
700 700  0END$: pop R3
... ... @@ -703,23 +703,21 @@
703 703   return
704 704  {{/code}}
705 705  
706 -**Обращаю внимание**, при записи, буфер идет сразу с данными, те нет первого слова со статусом.
708 +**Please note** that when recording, the buffer immediately comes with the data, i.e. there is no first word with the statu
707 707  
708 708  
709 709  
710 -= Блок команд для работы с RTC и NTP =
712 += Block of commands for working with RTC and NTP =
711 711  
712 -В контроллере AZ®  есть 2 источника получения даты-времени, первый это RTC встроенный в STM32, второй это часы в стеке TCP/IP.  Часы RTC работают автономно при наличии установленной батарейки 2032. Часы в стеке TCP/IP устанавливаются на основании данных с NTP-сервера.
714 +The AZ® controller has 2 sources of date-time, the first is the RTC built into the STM32, the second is the clock in the TCP/IP stack. The RTC clock works autonomously with a 2032 battery installed. The clock in the TCP/IP stack is set based on data from the NTP server.
713 713  
714 714  
715 -== Формат буфера timestamp (доступен по чтению) ==
717 +== Buffer format timestamp (readable) ==
716 716  
717 -API контроллера сразу готовит время в нескольких форматах, дабы его было удобно применить на стороне PDP-11
719 +The controller API immediately prepares time in several formats, so that it can be conveniently used on the PDP-11 side
718 718  
719 719  {{info}}
720 -формат буфера даты-времени
721 -offset в восьмеричной системе - те слова
722 -формат буфера даты-времени
722 +datetime buffer format octal offset - those words datetime buffer format
723 723  \\[0]=rtc_rt11date();
724 724  [2]=rt11 time 50Hz big word;
725 725  [4]=rt11 time 50Hz little word;
... ... @@ -737,72 +737,72 @@
737 737  {{/info}}
738 738  
739 739  
740 -== Формат буфера SimpleIN (при записи) ==
740 +== SimpleIN buffer format (when writing) ==
741 741  
742 -формат максимально упрощен, для работы со стороны PDP-11
742 +the format is simplified as much as possible, for work with PDP-11
743 743  
744 744  {{info}}
745 -offset в восьмеричной системе - те слова
745 +offset in octal - those words
746 746  
747 -[0]=year       год, младшие две цифры - те 22 а не 2022(!)
748 -[2]=month;     месяц
749 -[4]=day;       день
750 -[6]=wday;      день недели =0 не установлен, 1- понедельник 2 - вторник итд
751 -[10]=hour;     час
752 -[12]=min;      минута
753 -[14]=sec;      секунда
747 +[0]=year, the lower two digits are 22 and not 2022(!)
748 +[2]=month; month
749 +[4]=day; day
750 +[6]=wday; day of the week =0 not set, 1 - Monday 2 - Tuesday etc.
751 +[10]=hour; hour
752 +[12]=min; minute
753 +[14]=sec; second
754 754  {{/info}}
755 755  
756 756  
757 -== **031:  Получить время из RTC в буфер timestamp** ==
757 +== 031: Get time from RTC to timestamp buffer ==
758 758  
759 -Код команды 031, данная команда использует RTC часы как источник заполнения буфера timestamp
759 +Command code 031, this command uses RTC clock as a source of filling the timestamp buffer
760 760  
761 -Пример программы:
761 +Example program:
762 762  
763 763  {{code language="assembler"}}
764 -; trap 61 - чтение данных часов из автономных часов RTC
765 -; R3 - адрес буфера куда надо считать
766 -; результат в R3 адрес, если успешно. R3=0 если ошибка
764 +; trap 61 - reading clock data from autonomous RTC clock
765 +; R3 - buffer address where to read
766 +; result in R3 address if successful. R3=0 if error
767 767  GetDateFromRTC: push R0
768 768   push R1
769 769   push R2
770 - call AZreset; сбросим
770 + call AZreset; reset
771 771   tst R1
772 772   bne G60ERR
773 773   MOV #AZ$CSR,R1
774 774   mov #31,(R1)
775 - br G60; идем туда тк дальше код одинаковый
775 + br G60; let's go there because further code is the same
776 776  {{/code}}
777 777  
778 -== **032:  Получить время из буфера timestamp** ==
778 +== 032: Get time from timestamp buffer ==
779 779  
780 -Код команды 032, данная команда отдает на шину содержимое буфера timestamp
780 +Command code 032, this command sends the contents of the timestamp buffer to the bus
781 781  
782 782  {{code language="assembler"}}
783 -; работа с часами
784 -; trap 60 - чтение данных часов из TCP/IP стека
785 -; R3 - адрес буфера куда надо считать
786 -; результат в R3 адрес, если успешно. R3=0 если ошибка
783 +; working with clock
784 +; trap 60 - reading clock data from TCP/IP stack
785 +; R3 - buffer address where to read
786 +; result in R3 address if successful. R3=0 if error
787 787  GetDateFromLAN: push R0
788 788   push R1
789 789   push R2
790 - call AZreset; сбросим
790 + call AZreset; reset
791 791   tst R1
792 792   bne G60ERR
793 793   MOV #AZ$CSR,R1
794 794   mov #42,(R1)
795 -G60: TSTB (R1); проверяем результат выполнения
796 - BPL G60; ждем
795 +G60: TSTB (R1); check execution result
796 + BPL G60; wait
797 797   mov #32,(R1)
798 -1$: TSTB (R1); проверяем результат выполнения
798 +1$: TSTB (R1); check execution result
799 799   BPL 1$; ждем
800 - TST (R1)+; инкрементируем
801 - mov R3,R0; запомним R3 - адрес
802 - mov #10.,R2; читаем 10 слов
803 -2$: mov (R1),(R3)+; читаем блок слов в память
800 + TST (R1)+; increment
801 + mov R3,R0; remember R3 address
802 + mov #10.,R2; read 10 words
803 +2$: mov (R1),(R3)+; read block of words into memory
804 804   sob R2,2$
805 - mov R0,R3; успешно, вернем адрес в R3
805 + mov R0,R3; successful, return address to R3
806 806   br 0END$
807 807  G60ERR: CLR R3
808 808  0END$: pop R2
... ... @@ -811,11 +811,11 @@
811 811   return
812 812  {{/code}}
813 813  
814 -Стоит проверить корректность полученного времени:
814 +It is worth checking the correctness of the received time:
815 815  
816 816  {{code language="assembler"}}
817 -; trap 63 - проверка корректности времени
818 -; R3 - адрес буфера, результат в R3, если адрес буфера то OK, =0 ошибка
817 +; trap 63 - check time correctness
818 +; R3 - buffer address, result in R3, if buffer address then OK, =0 error
819 819  CheckDateTime: Cmp 6(r3),#2021.
820 820   Blos 1err
821 821   Cmp 6(r3),#2100.
... ... @@ -825,119 +825,119 @@
825 825   return
826 826  {{/code}}
827 827  
828 -== **033:  Запись времени-даты в буфер SimpleIN** ==
828 +== 033: Write time-date to SimpleIN buffer ==
829 829  
830 -Код команды 033, данная команда  принимает с шины данные в буфер SimpleIN
830 +Command code 033, this command receives data from the bus into the SimpleIN buffer
831 831  
832 -Работа данной команды аналогична работе команд [[023>>doc:||anchor="H023:41F44043843D44F44244C44144843843D44B43243144344443544043443043D43D44B43543443B44F43F43E44143B43543444344E44943543943743043F438441438432431443444435440"]] и [[016>>doc:||anchor="H016:A041F44043843D44F44244C43143B43E43A43443043D43D44B445432431443444435440"]].
832 +The operation of this command is similar to the operation of commands 023 and 016.
833 833  
834 -== **034:  Установка RTC на основании данных из буфера** ==
834 +== 034: Set RTC based on buffer data ==
835 835  
836 -Код команды 034, данная команда  устанавливает RTC на основании данных в буфере SimpleIN
836 +Command code 034, this command sets the RTC based on the data in the SimpleIN buffer
837 837  
838 -Данная команда выполняется быстро, но для исключения проблем цикл ожидания выполнения рекомендуется.
838 +This command executes quickly, but to avoid problems, a wait loop is recommended.
839 839  
840 -== **035:  Стимуляция запроса времени с NTP сервера, установка на основании ответа** ==
840 +== 035: Stimulate time request from NTP server, set based on response ==
841 841  
842 -Код команды 035, данная команда отправляет запрос на NTP cервер (установленный в AZ.INI файле или полученный от DHCP) и устанавливает часы в стеке TCP/IP.
842 +Command code 035, this command sends a request to the NTP server (set in the AZ.INI file or received from DHCP) and sets the clock in the TCP/IP stack.
843 843  
844 -Пример программы: отсылка запроса на установку времени с NTP сервера
844 +Example program: sending a request to set the time from an NTP server
845 845  
846 846  {{code language="assembler"}}
847 -; trap 62 - отсылка запроса на установку времени с NTP сервера
847 +; trap 62 - sending a request to set the time from the NTP server
848 848  GetDateNTPtoNET:push R1
849 - call AZreset; сбросим
849 + call AZreset; reset
850 850   tst R1
851 851   bne 0ERR$
852 852   MOV #AZ$CSR,R1
853 853   mov #35,(R1)
854 -0$: TSTB (R1); проверяем результат выполнения
855 - BPL 0$; ждем
854 +0$: TSTB (R1); check the result of execution
855 + BPL 0$; wait
856 856  0ERR$: pop R1
857 857   return
858 858  {{/code}}
859 859  
860 -Выполнение команды занимает 1-2 секунды в среднем. Данная команда требует работы стека TCP/IP, соответственно нужны циклы ожидания при включенном стеке.
860 +The command execution takes 1-2 seconds on average. This command requires the TCP/IP stack to work, so waiting cycles are needed when the stack is enabled.
861 861  
862 -Пример цикла опроса с целью получить время с сети
862 +An example of a polling cycle to get time from the network
863 863  
864 864  {{code language="assembler"}}
865 -; дата-время
865 +; date-time
866 866   mov #S_DateTime_0,R3; "Lan Date:"
867 867   trap 10
868 - mov #20,R4; количество циклов ожидания
869 -$datry: trap 62; отослали запрос к NTP серверу
870 - mov #110,@#AZ$CSR; включим сеть
871 - trap 47; ожидание
872 - trap 47; ожидание
868 + mov #20,R4; number of wait cycles
869 +$datry: trap 62; sent a request to the NTP server
870 + mov #110,@#AZ$CSR; enable the network
871 + trap 47; waiting
872 + trap 47; waiting
873 873   mov #ADRTMPSTR,R3
874 - trap 60; считали в буфер дату-время
875 - trap 63; проверили дату-время
874 + trap 60; read the date-time into the buffer
875 + trap 63; checked the date-time
876 876   tst R3
877 877   bne $ok
878 878  $sob: sob R4,$datry
879 - mov #S_DateTime_2,R3; печать ошибки
879 + mov #S_DateTime_2,R3; print error
880 880   trap 7
881 881   br $go
882 882  
883 883  $ok: mov #ADRTMPSTR,R3
884 - trap 24; печать даты
885 - trap 25; времени
886 -$go: mov #110,@#AZ$CSR; включим сеть
884 + trap 24; print date
885 + trap 25; time
886 +$go: mov #110,@#AZ$CSR; let's turn on the network
887 887  {{/code}}
888 888  
889 -Тут мы явно отсылаем запрос к NTP серверу, затем включаем работу сети и ждем результата, периодически опрашивая и проверяя корректность результата.
889 +Here we explicitly send a request to the NTP server, then turn on the network and wait for the result, periodically polling and checking the correctness of the result.
890 890  
891 -== **036:  Установка RTC на основании часов TCP/IP стека** ==
891 +== 036: Setting RTC based on TCP/IP stack clock ==
892 892  
893 -Код команды 036,  данная команда устанавливает RTC на основании часов в TCP/IP стека. Предварительно надо установить часы в TCP/IP - команда 036.
893 +Command code 036, this command sets the RTC based on the clock in the TCP/IP stack. You must first set the clock in TCP/IP - command 036.
894 894  
895 -Пример программы:
895 +Example program:
896 896  
897 897  {{code language="assembler"}}
898 -; trap 64 - установка времени RTC на основании времени стека
899 -; R1 - результат R1=0 - OK
900 -SetDateNETtoRTC:call AZreset; сбросим
898 +; trap 64 - set RTC time based on stack time
899 +; R1 - result R1=0 - OK
900 +SetDateNETtoRTC:call AZreset; reset
901 901   tst R1
902 902   bne 0ERR$
903 903   MOV #AZ$CSR,R1
904 904   mov #36,(R1)
905 -0$: TSTB (R1); проверяем результат выполнения
906 - BPL 0$; ждем
905 +0$: TSTB (R1); check execution result
906 + BPL 0$; wait
907 907   clr R1
908 908  0ERR$: return
909 909  {{/code}}
910 910  
911 -== **042:  Получить время из часов TCP/IP стека в буфер timestamp** ==
911 +== 042: Get time from TCP/IP stack clock into timestamp buffer ==
912 912  
913 -Код команды 042,   данная команда использует часы TCP/IP стека как источник заполнения буфера timestamp.
913 +Command code 042, this command uses the TCP/IP stack clock as a source for filling the timestamp buffer.
914 914  
915 -Пример программы:
915 +Example program:
916 916  
917 917  {{code language="assembler"}}
918 -; работа с часами
919 -; trap 60 - чтение данных часов из TCP/IP стека
920 -; R3 - адрес буфера куда надо считать
921 -; результат в R3 адрес, если успешно. R3=0 если ошибка
918 +; working with clock
919 +; trap 60 - reading clock data from TCP/IP stack
920 +; R3 - buffer address where to read
921 +; result in R3 address if successful. R3=0 if error
922 922  GetDateFromLAN: push R0
923 923   push R1
924 924   push R2
925 - call AZreset; сбросим
925 + call AZreset; reset
926 926   tst R1
927 927   bne G60ERR
928 928   MOV #AZ$CSR,R1
929 929   mov #42,(R1)
930 -G60: TSTB (R1); проверяем результат выполнения
931 - BPL G60; ждем
930 +G60: TSTB (R1); check execution result
931 + BPL G60; wait
932 932   mov #32,(R1)
933 -1$: TSTB (R1); проверяем результат выполнения
934 - BPL 1$; ждем
935 - TST (R1)+; инкрементируем
936 - mov R3,R0; запомним R3 - адрес
933 +1$: TSTB (R1); check execution result
934 + BPL 1$; wait
935 + TST (R1)+; increment
936 + mov R3,R0; remember R3 address
937 937   mov #10.,R2; читаем 10 слов
938 -2$: mov (R1),(R3)+; читаем блок слов в память
938 +2$: mov (R1),(R3)+; read block of words into memory
939 939   sob R2,2$
940 - mov R0,R3; успешно, вернем адрес в R3
940 + mov R0,R3; successful, return address to R3
941 941   br 0END$
942 942  G60ERR: CLR R3
943 943  0END$: pop R2
... ... @@ -946,52 +946,50 @@
946 946   return
947 947  {{/code}}
948 948  
949 -все команды устанавливают бит готовности по завершению.
949 +All commands set the ready bit upon completion.
950 950  
951 951  
952 -= **Команды специфические для [[AZБК®>>doc:Контроллеры AZБК® для компьютеров БК-0010 БК-0010\.01 БК-0011М.WebHome]]** =
952 += **[[AZБК®>>doc:Контроллеры AZБК® для компьютеров БК-0010 БК-0010\.01 БК-0011М.WebHome]] **specific commands =
953 953  
954 -Данные команды предназначены для работы контроллера AZБК®, разработанного для серии компьютеров БК - БК-0010/БК-0010.01/БК-0011М.
954 +These commands are intended for operation of the AZБК® controller, developed for the BK series of computers - BK-0010/BK-0010.01/BK-0011M.
955 955  
956 -Другие контроллеры AZ® игнорируют эти команды
956 +Other AZ® controllers ignore these commands.
957 957  
958 -== **037: перезапуск контроллера [[AZБК®>>doc:Контроллеры AZБК® для компьютеров БК-0010 БК-0010\.01 БК-0011М.WebHome]] и всей БК** ==
958 +== 037: Restart of the** [[AZБК®>>doc:Контроллеры AZБК® для компьютеров БК-0010 БК-0010\.01 БК-0011М.WebHome]] **controller and the entire computer ==
959 959  
960 -Код команды 037,  данная команда осуществляет перезапуск микроконтроллера AZ®, что вызывает и перезапуск самой БК-0010/БК-0010.01/БК-0011М
960 +Command code 037, this command restarts the AZ® microcontroller, which also causes a restart of the BK-0010/BK-0010.01/BK-0011M itself
961 961  
962 -Пример программы
962 +Example program
963 963  
964 964  {{code language="assembler"}}
965 -AZ$CSR = 177220; регистр команд и состояния (CSR)
966 -AZ$DR = 177222; регистр данных (DR)
965 +AZ$CSR = 177220; command and status register (CSR)
966 +AZ$DR = 177222; data register (DR)
967 967  
968 968  
969 -; trap 57 - перезапуск БК полный
970 -AZcouldReboot: call AZreset; сбросим AZ дабы он был готов принимать команды
969 +; trap 57 - full restart
970 +AZcouldReboot: call AZreset; reset AZ so it is ready to receive
971 971   mov #037,@#AZ$CSR
972 972   return
973 973  {{/code}}
974 974  
975 -== **044: Cохранение скриншота в файл** ==
975 +== 044: Saving a screenshot to a file ==
976 976  
977 -Код команды 044,  данная команда предназначена для снятия образа памяти указанного размера (или определенного автоматически на основании сохраненных параметров)
978 -технически команда может служить как средство отладки ибо способная снимать образ памяти
979 -общее ограничение на снятие образа памяти - 2МБ на один образ
980 -\\в качестве параметров используется служебная страница памяти 76(8)
977 +Command code 044, this command is designed to take a memory image of the specified size (or determined automatically based on saved parameters) technically, the command can serve as a debugging tool because it is capable of taking a memory image the general limitation on taking a memory image is 2MB per image
978 +\\service memory page 76(8) is used as parameters
981 981  
982 -Структура заполнения информации о скриншоте
980 +Structure of filling information about a screenshot
983 983  
984 984  {{code language="c"}}
985 -// структура хидера скриншота
983 +// screenshot header structure
986 986  typedef __packed struct screen_header
987 987  {
988 - unsigned short int tag; // должен быть равен 0240
986 + unsigned short int tag; // must be equal to 0240
989 989  
990 - unsigned int begin_adress; // начальный адрес в словах - прямая задача в физических адресах
991 - unsigned int length; // длина в словах - прямая задача в физических адресах
988 + unsigned int begin_adress; // start address in words - forward task in physical addresses
989 + unsigned int length; // length in words - forward task in physical addresses
992 992  
993 - unsigned short int begin_page; // начальная страница - номер - прямая задача в номерах страниц
994 - unsigned short int len_pages; // количество страниц - прямая задача в номерах страниц
991 + unsigned short int begin_page; // start page - number - forward task in page numbers
992 + unsigned short int len_pages; // number of pages - forward task in page numbers
995 995  
996 996   unsigned short int R177300; //
997 997   unsigned short int R177302; //
... ... @@ -1009,57 +1009,55 @@
1009 1009   unsigned short int R177332; //
1010 1010   unsigned short int R177334; //
1011 1011   unsigned short int R177336; //
1012 - unsigned short int R177340; // - Регистр управления активацией окно - маски окон
1013 - unsigned short int R177342; // - Регистр управления r/o на окно
1014 - unsigned short int R177344; // - Регистр управления shadow окон - маски окон
1015 - unsigned short int R177346; // - Регистр управления маппером
1016 - unsigned short int R177350; // - регистр копия по записи 177130 в режиме записи управления памятью в SMK
1017 - unsigned short int R177352; // - регистр копия по записи 177716 в режиме записи управления памятью в БК11М
1010 + unsigned short int R177340; // - Window activation control register - window masks
1011 + unsigned short int R177342; // - Control register r/o per window
1012 + unsigned short int R177344; // - Shadow window control register - window masks
1013 + unsigned short int R177346; // - Mapper control register
1014 + unsigned short int R177350; // - copy by record register 177130 in memory management write mode in SMK
1015 + unsigned short int R177352; // - copy by record register 177716 in memory management write mode in BK11M
1018 1018  
1019 - unsigned short int R177230; // - регистр управления
1020 - unsigned short int R177232; // - регистр номера страницы начала отображения - верхняя страница (слой 0)
1021 - unsigned short int R177240; // - регистр номера страницы начала отображения - средняя страница (слой 1)
1022 - unsigned short int R177242; // - регистр номера страницы начала отображения - нижняя страница (слой 2)
1023 - unsigned short int R177244; // - регистр вертикального скролинга слой 2
1024 - unsigned short int R177246; // - регистр вертикального скролинга слой 1
1025 - unsigned short int R177250; // - регистр вертикального скролинга слой 0
1026 - unsigned short int R177252; // - регистр гозизонтального скролинга слой 0
1027 - unsigned short int R177254; // - регистр гозизонтального скролинга слой 1
1028 - unsigned short int R177256; // - регистр гозизонтального скролинга слой 2
1017 + unsigned short int R177230; // - control register
1018 + unsigned short int R177232; // - display start page number register - upper page (layer 0)
1019 + unsigned short int R177240; // - display start page number register - upper page (layer 1)
1020 + unsigned short int R177242; // - display start page number register - upper page (layer 2)
1021 + unsigned short int R177244; // - vertical scroll register layer 2
1022 + unsigned short int R177246; // - vertical scroll register layer 1
1023 + unsigned short int R177250; // - vertical scroll register layer 0
1024 + unsigned short int R177252; // - horizontal scroll register layer 0
1025 + unsigned short int R177254; // - horizontal scroll register layer 1
1026 + unsigned short int R177256; // - horizontal scroll register layer 2
1029 1029  
1030 1030   unsigned short int paldata[338]; //
1031 1031  } screen_header_t;
1032 1032  {{/code}}
1033 1033  
1034 -Пример кода для заполнения страницы памяти
1032 +Example code for filling a memory page
1035 1035  
1036 1036  {{code language="assembler"}}
1037 1037  ;--------------------------------------------------
1038 -; карта 76й страницы - туда мы готовим данные для команды скринщотов
1039 - SCR_PAGE = 130000 ; 76ую страницу цепляем на место 77й временно - те в окно 130000
1040 - SCR_TAG = SCR_PAGE+0 ; тут вход - 240 - 1 слово
1041 - SCR_ADDR_CONF = SCR_TAG+2 ; сюда команду с адресами - адрес+длина 24 бита - 4 слова
1042 - SCR_PAGE_CONF = SCR_ADDR_CONF+8. ; сюда команду со страницами - начальная страница и количество страниц - 2 слова
1043 - SCR_MEM_CONF = SCR_PAGE_CONF+4. ; cюда конфигурацию памяти из регистров - 22 слова
1044 - SCR_VGA_CONF = SCR_MEM_CONF+44. ; сюда конфигурацию видеоконтроллера - 10 cлов
1045 - SCR_PAL = SCR_VGA_CONF+20. ; сюда 338. значений(слов) палитры 338 слов
1036 +; 76th page map - we prepare data for the screenshot command there
1037 +SCR_PAGE = 130000 ; we temporarily attach the 76th page to the 77th - that is, into the 130000 window
1038 +SCR_TAG = SCR_PAGE+0 ; here is the input - 240 - 1 word
1039 +SCR_ADDR_CONF = SCR_TAG+2 ; here is the command with addresses - address+length 24 bits - 4 words
1040 +SCR_PAGE_CONF = SCR_ADDR_CONF+8. ; here is the command with pages - the starting page and the number of pages - 2 words
1041 +SCR_MEM_CONF = SCR_PAGE_CONF+4. ; here is the memory configuration from the registers - 22 words
1042 +SCR_VGA_CONF = SCR_MEM_CONF+44. ; here video controller configuration - 10 words
1043 +SCR_PAL = SCR_VGA_CONF+20. ; here 338. values (words) of palette 338 words
1046 1046  ;--------------------------------------------------
1045 +; trap 41 - preparation of default information for screenshot functionality
1046 +PrepSRC: jsr R5, PUSHA ; batch saving of registers
1047 + mov @#177326,-(SP) ; save page 130k which was before the call
1048 + mov #76,@#177326 ; hook 76th page into window
1047 1047  
1048 -
1049 -; trap 41 - подготовка дефолтной информации для работы функционала скриншотов
1050 -PrepSRC: jsr R5, PUSHA ; пакетное сохранение регистров
1051 - mov @#177326,-(SP) ; сохраним страницу 130k которая была до вызова
1052 - mov #76,@#177326 ; цепляем 76ую страницу в окно
1053 -
1054 - mov #100377,R3 ; константа-заполнитель
1050 + mov #100377,R3 ; constant-filler
1055 1055   mov #SCR_PAGE,R4
1056 1056   mov #2047.,R2
1057 1057  4$: mov R3,(R4)+
1058 1058   sob R2,4$
1059 1059  
1060 - mov #240,@#SCR_TAG ; проставляем тег
1056 + mov #240,@#SCR_TAG ; put the tag
1061 1061  
1062 - ; чистим участок адресов - дефолтно автоматическое определение адресов
1058 + ; clean the address section - default is automatic address detection
1063 1063   clr R3
1064 1064   mov #SCR_ADDR_CONF,R4
1065 1065   mov #10,R2
... ... @@ -1066,7 +1066,7 @@
1066 1066  2$: mov R3,(R4)+
1067 1067   sob R2,2$
1068 1068  
1069 - ;конфигурация памяти - дефолтная
1065 + ; memory configuration - default
1070 1070   mov #SCR_MEM_CONF,R4
1071 1071   mov #30,(R4)+ ;177300
1072 1072   mov #31,(R4)+ ;177302
... ... @@ -1085,29 +1085,29 @@
1085 1085   mov #110,(R4)+ ;177334
1086 1086   mov #100,(R4)+ ;177336
1087 1087  
1088 - mov #170000,(R4)+ ;177340 - Регистр управления активацией окно - маски окон
1089 - mov R3,(R4)+ ;177342 - Регистр управления r/o на окно
1090 - mov #7777,(R4)+ ;177344 - Регистр управления shadow окон - маски окон
1091 - mov #40404,(R4)+ ;177346 - Регистр управления маппером
1092 - mov R3,(R4)+ ;177350 - регистр копия по записи 177130 в режиме записи управления памятью в SMK
1093 - mov #16000,(R4)+ ;177352 - регистр копия по записи 177716 в режиме записи управления памятью в БК11М
1084 + mov #170000,(R4)+ ;177340
1085 + mov R3,(R4)+ ;177342
1086 + mov #7777,(R4)+ ;177344
1087 + mov #40404,(R4)+ ;177346
1088 + mov R3,(R4)+ ;177350
1089 + mov #16000,(R4)+ ;177352
1094 1094  
1095 - ;конфигурация видеоконтроллера - дефолтная
1091 + ;Video controller configuration - default
1096 1096   ; 177230-177256
1097 1097   mov #SCR_VGA_CONF,R4
1098 1098  
1099 - mov #12201,(R4)+ ;177230 - регистр управления
1100 - mov #4,(R4)+ ;177232 - регистр номера страницы начала отображения - верхняя страница (слой 0)
1101 - mov R3,(R4)+ ;177240 - регистр номера страницы начала отображения - средняя страница (слой 1) "под спрайты"
1102 - mov R3,(R4)+ ;177242 - регистр номера страницы начала отображения - нижняя страница (слой 2) "под фон"
1103 - mov R3,(R4)+ ;177244 - регистр вертикального скролинга слой 2
1104 - mov R3,(R4)+ ;177246 - регистр вертикального скролинга слой 1
1105 - mov R3,(R4)+ ;177250 - регистр вертикального скролинга слой 0
1106 - mov R3,(R4)+ ;177252 - регистр гозизонтального скролинга слой 0
1107 - mov R3,(R4)+ ;177254 - регистр гозизонтального скролинга слой 1
1108 - mov R3,(R4)+ ;177256 - регистр гозизонтального скролинга слой 2
1095 + mov #12201,(R4)+ ;177230
1096 + mov #4,(R4)+ ;177232
1097 + mov R3,(R4)+ ;177240
1098 + mov R3,(R4)+ ;177242
1099 + mov R3,(R4)+ ;177244
1100 + mov R3,(R4)+ ;177246
1101 + mov R3,(R4)+ ;177250
1102 + mov R3,(R4)+ ;177252
1103 + mov R3,(R4)+ ;177254
1104 + mov R3,(R4)+ ;177256
1109 1109  
1110 - ; закачиваем палитру - берем дефолтную из этой ПЗУшки
1106 + ; download the palette - take the default one from this ROM
1111 1111   mov #SCR_PAL,R4
1112 1112   mov #PalData,R2
1113 1113   mov #338.,R3
... ... @@ -1114,233 +1114,233 @@
1114 1114  1$: mov (R2)+,(R4)+
1115 1115   sob R3,1$
1116 1116  
1117 - mov (SP)+,@#177326; вернем страницу с которой был вызов
1113 + mov (SP)+,@#177326; return the page from which the call was made
1118 1118   return
1119 1119  {{/code}}
1120 1120  
1121 -Вариантов указания участков памяти три
1117 +There are three options for specifying memory areas.
1122 1122  
1123 -1. указать адрес и длину 24х битные - формат, если их нет - система смотрит дальше
1124 -1. указать номер страницы и количество страницы, если их нет
1125 -1. система смотрит дальше - те делает скриншот на основании данных о регистрах 177230 и т.д..
1119 +1. specify the address and length 24-bit - see format, if they are not there - the system looks further
1120 +1. specify the page number and page quantity, if they are not there
1121 +1. the system looks further - that is, it makes a screenshot based on the data about registers 177230, etc.
1126 1126  
1127 -Cкриншот сохраняется в формате
1128 -- страница 76 - ее первый килобайт
1129 -- сам образ памяти (если режим слоеный - то все три слоя)
1123 +The screenshot is saved in the format
1124 +- page 76 - its first kilobyte
1125 +- the memory image itself (if the mode is layered - then all three layers)
1130 1130  
1131 1131  
1132 -Перед вызовом команды можно загрузить имя файла для сохранения скриншота [в cmosmem буфер], однако при его отсутствии (в буфере не будет имени - строки заканчивающейся 0) система сформирует свое имя, на основании следующего правила:
1133 -дефолтный путь для сохранения скриншотов
1128 +Before calling the command, you can load the file name for saving the screenshot [in the cmosmem buffer], but if it is missing (there will be no name in the buffer - a line ending with 0), the system will generate its own name based on the following rule: default path for saving screenshots
1134 1134  0:/SCREENS/
1135 -формат имени - DDHHMISS.SCR
1136 -где DD - две цифры дня месяца, HH - час, MI - минута, SS-секунда
1137 -\\Если в процессе выполнения команды возникнет ошибка - вместо имени будет "ERROR *"
1138 -к примеру
1130 +name format - DDHHMISS.SCR
1131 +where DD is two digits of the day of the month, HH is the hour, MI is the minute, SS is the second
1132 +\\If an error occurs during the command execution, the name will be "ERROR *"
1133 +for example
1139 1139  "ERROR f_open 6"
1140 1140  
1141 1141  
1142 -Пример программы
1137 +Example program
1143 1143  
1144 1144  {{code language="assembler"}}
1145 -; обновим информацию в хидере скриншота
1140 +; update the information in the screenshot header
1146 1146  ;--------------------------------------------------
1147 -; карта 76й страницы - туда мы готовим данные для команды скринщотов
1148 - SPAGE = 170000 ; 76ую страницу цепляем на место 77й временно - те в окно 130000
1149 - STAG = SPAGE+0 ; тут вход - 240 - 1 слово
1150 - SADDRC = STAG+2 ; сюда команду с адресами - адрес+длина 24 бита - 4 слова
1151 - SPAGEC = SADDRC+8. ; сюда команду со страницами - начальная страница и количество страниц - 2 слова
1152 - SMEMC = SPAGEC+4. ; cюда конфигурацию памяти из регистров - 22 слова
1153 - SVGAC = SMEMC+44. ; сюда конфигурацию видеоконтроллера - 10 cлов
1154 - SPAL = SVGAC+20. ; сюда 338. значений(слов) палитры 338 слов
1142 +; 76th page map - we prepare data for the screenshot command there
1143 +SCR_PAGE = 130000 ; we temporarily attach the 76th page to the 77th - that is, into the 130000 window
1144 +SCR_TAG = SCR_PAGE+0 ; here is the input - 240 - 1 word
1145 +SCR_ADDR_CONF = SCR_TAG+2 ; here is the command with addresses - address+length 24 bits - 4 words
1146 +SCR_PAGE_CONF = SCR_ADDR_CONF+8. ; here is the command with pages - the starting page and the number of pages - 2 words
1147 +SCR_MEM_CONF = SCR_PAGE_CONF+4. ; here is the memory configuration from the registers - 22 words
1148 +SCR_VGA_CONF = SCR_MEM_CONF+44. ; here video controller configuration - 10 words
1149 +SCR_PAL = SCR_VGA_CONF+20. ; here 338. values (words) of palette 338 words
1155 1155  ;--------------------------------------------------
1151 + mov @#177326,R5 ; save page 130k which was before the call
1152 + mov #76,@#177336 ; hook the 76th page into the window
1156 1156  
1157 - mov @#177326,R5 ; сохраним страницу 130k которая была до вызова
1158 - mov #76,@#177336 ; цепляем 76ую страницу в окно
1159 -
1160 - ;конфигурация видеоконтроллера
1154 + ;video controller configuration
1161 1161   ; 177230-177256
1162 1162   mov #SVGAC,R4
1163 1163  
1164 - mov @#177230,(R4)+;177230 - регистр управления
1165 - mov @#177232,(R4)+;177232 - регистр - верхняя страница (слой 0)
1166 - mov @#177240,(R4)+;177240 - регистр - средняя страница (слой 1)
1167 - mov @#177242,(R4)+;177242 - регистр - нижняя страница (слой 2)
1168 - mov @#177244,(R4)+;177244 - регистр вертикального скролинга слой 2
1169 - mov @#177246,(R4)+;177246 - регистр вертикального скролинга слой 1
1170 - mov @#177250,(R4)+;177250 - регистр вертикального скролинга слой 0
1171 - mov @#177252,(R4)+;177252 - регистр гозизонтального скролинга слой 0
1172 - mov @#177254,(R4)+;177254 - регистр гозизонтального скролинга слой 1
1173 - mov @#177256,(R4)+;177256 - регистр гозизонтального скролинга слой 2
1158 + mov @#177230,(R4)+;177230 - control register
1159 + mov @#177232,(R4)+;177232 - register - top page (layer 0)
1160 + mov @#177240,(R4)+;177240 - register - top page (layer 1)
1161 + mov @#177242,(R4)+;177242 - register - top page (layer 2)
1162 + mov @#177244,(R4)+;177244 - vertical scroll register layer 2
1163 + mov @#177246,(R4)+;177246 - vertical scroll register layer 1
1164 + mov @#177250,(R4)+;177250 - vertical scroll register layer 0
1165 + mov @#177252,(R4)+;177252 - horizontal scroll register layer 0
1166 + mov @#177254,(R4)+;177254 - horizontal scroll register layer 1
1167 + mov @#177256,(R4)+;177256 - horizontal scroll register layer 2
1174 1174  
1175 - mov R5,@#177336; вернем страницу с которой был вызов
1169 + mov R5,@#177336; return the page from which the call was made
1176 1176  
1177 1177  
1178 1178   ;-------------------------
1179 - MOV #AZ$CSR,R3 ; Готовим CSR контроллера
1180 - MOV #AZ$DR,R4 ; Готовим DR контроллера
1181 -20$: CLR (R3) ; Сбросим контроллер
1173 + MOV #AZ$CSR,R3 ; Preparing controller CSR
1174 + MOV #AZ$DR,R4 ; Preparing controller DR
1175 +20$: CLR (R3) ; Reset the controller
1182 1182   TSTB (R3)
1183 1183   BPL 20$
1184 1184  
1185 - ; очистим блок памяти для имени - дабы система сделала дефолтное имя файла
1186 - mov #23,(R3) ; командуем что будем писать данные в буфер
1187 -128$: TSTB (R3) ; проверяем результат выполнения
1188 - BPL 128$ ; ждем
1179 + ; clear the memory block for the name - so that the system makes a default file name
1180 + mov #23,(R3) ; command that we will write data to the buffer
1181 +128$: TSTB (R3) ; check the result of execution
1182 + BPL 128$ ; wait
1189 1189   clr R1
1190 1190  
1191 1191   mov #256.,R2 ;
1192 -129$: mov R1,(R4) ; отдаем в контроллер
1186 +129$: mov R1,(R4) ; give to the controller
1193 1193   sob R2,129$
1194 1194  
1195 1195  
1196 - MOV #044,(R3) ; команда скриншот
1190 + MOV #044,(R3) ; screenshot command
1197 1197  22$: TSTB (R3) ;
1198 1198   BPL 22$ ;
1199 1199  
1200 - ; получим имя скриншота
1201 - mov #22,(R3) ; отдать на шину считанный блок памяти из буфера
1202 -121$: tstb (R3) ; проверяем результат выполнения
1203 - bpl 121$ ; ждем
1194 + ; get the screenshot name
1195 + mov #22,(R3) ; give the read memory block from the buffer to the bus
1196 +121$: tstb (R3) ; check the result of execution
1197 + bpl 121$ ; wait
1204 1204  
1205 1205   mov #BUF,R1
1206 - mov #256.,R2 ; читаем 256. слов; первое слово - результат чтения
1207 -122$: mov (R4),(R1)+ ; читаем блок слов в память
1200 + mov #256.,R2 ; read 256. words; the first word is the result of reading
1201 +122$: mov (R4),(R1)+ ; read a block of words into memory
1208 1208   sob R2,122$
1209 1209  
1210 1210   .PRINT #RESOK
1211 1211   .Print #BUF
1212 1212  
1213 - mov #110,@#AZ$CSR; включаем сеть по-умолчанию сеть должна быть постоянно включена
1207 + mov #110,@#AZ$CSR; enable the network by default, the network should be constantly enabled
1214 1214   .Exit
1215 1215  {{/code}}
1216 1216  
1217 -Для распаковки скриншота можно использовать вот эту утилиту
1211 +To unpack a screenshot, you can use this utility - [[https:~~/~~/master.pdp-11.ru/screen_unpack/>>https://master.pdp-11.ru/screen_unpack/]]
1218 1218  
1219 1219  
1220 1220  
1221 -= **Команды для работы со стеком TCP/IP** =
1215 += Commands for working with the TCP/IP stack =
1222 1222  
1223 -следующие команды работают с буфером информации TCP/IP cтека.
1217 +The following commands operate on the TCP/IP stack information buffer.
1224 1224  
1225 -== **040: Получить ip адрес и прочие настройки стека TCP/IP в буфер** ==
1219 +== 040: Get IP address and other TCP/IP stack settings to buffer ==
1226 1226  
1227 -Код команды 040,  данная команда заполняет буфер информацией с TCP/IP cтека текущей (фактической) информацией.
1221 +Command code 040, this command fills the buffer with information from the TCP/IP stack with current (actual) information.
1228 1228  
1229 -== **041: Чтение буфера ip адреса** ==
1223 +== 041: Reading ip address buffer ==
1230 1230  
1231 -Код команды 041,  данная команда передает буфер на шину
1225 +Command code 041, this command transfers the buffer to the bus
1232 1232  
1233 -эта пара команд позволяет получить текущую информацию со стека
1227 +This pair of commands allows you to get current information from the stack
1234 1234  
1235 -* IP адрес
1236 -* MASK маску
1237 -* GW гейтвей
1238 -* NTP адрес NTP-сервера
1239 -* DNS1 адрес основного DNS
1240 -* DNS2 адрес резервного DNS
1229 +* IP address
1230 +* MASK mask
1231 +* GW gateway
1232 +* NTP address of the NTP server
1233 +* DNS1 primary DNS address
1234 +* DNS2 backup DNS address
1241 1241  
1242 -соответственно это 12 слов
1236 +accordingly it is 12 words
1243 1243  
1244 -Пример программы:
1238 +Example program:
1245 1245  
1246 1246  {{code language="assembler"}}
1247 -; trap 52 - чтение блока IP адресов в блок памяти IPADDDBLOCK (8. ячеек)
1248 -; результат в R3 =0 error, иначе адрес куда считано (IPADDDBLOCK)
1249 -GetIPaddrs: push R1
1250 - push R2
1251 - call AZreset; сбросим
1252 - tst R1
1253 - bne 0ERR$
1254 - MOV #AZ$CSR,R1
1255 - mov #40,(R1)
1256 -0$: TSTB (R1); прочитать адреса в свою память
1257 - BPL 0$; ждем
1258 - mov #41,(R1)
1259 -1$: TSTB (R1); подготовить буфер
1260 - BPL 1$; ждем
1261 - TST (R1)+; инкрементируем
1262 - mov #IPADDDBLOCK,R3
1263 - mov #12.,R2
1264 -2$: mov (R1),(R3)+; читаем блок слов в память
1265 - sob R2,2$
1266 - mov #IPADDDBLOCK,R3; успешно
1267 - br 0END$
1268 -0ERR$: CLR R3
1269 -0END$: pop R2
1270 - pop R1
1271 - return
1241 +; trap 52 - reading a block of IP addresses into the IPADDDBLOCK memory block (8 cells)
1242 +; result in R3 = 0 if error, otherwise the address where it was read (IPADDDBLOCK)
1243 +GetIPaddrs: push R1
1244 + push R2
1245 + call AZreset; reset
1246 + tst R1
1247 + bne 0ERR$
1248 + MOV #AZ$CSR,R1
1249 + mov #40,(R1)
1250 +0$: TSTB (R1); read addresses into its memory
1251 + BPL 0$; wait
1252 + mov #41,(R1)
1253 +1$: TSTB (R1); prepare buffer
1254 + BPL 1$; wait
1255 + TST (R1)+; increment
1256 + mov #IPADDDBLOCK,R3
1257 + mov #12.,R2
1258 +2$: mov (R1),(R3)+; read block of words into memory
1259 + sob R2,2$
1260 + mov #IPADDDBLOCK,R3; success
1261 + br 0END$
1262 +0ERR$: CLR R3
1263 +0END$: pop R2
1264 + pop R1
1265 + return
1266 +
1272 1272  {{/code}}
1273 1273  
1274 -Пример данных
1269 +Example return data:
1275 1275  
1276 1276  {{info}}
1277 -Примеры данных - возвращаемые слова в восьмеричном формате
1278 -124300 116400 - IP адрес 192.168.0.157
1279 -177777 000377 - MASK маску 255.255.255.0
1280 -124300 000400 - GW гейтвей 192.168.0.1
1281 -124300 000400 - NTP адрес NTP-сервера 192.168.0.1
1282 -124300 050000 - DNS1 адрес основного DNS 192.168.0.90
1283 -124300 055000 - DNS2 адрес резервного DNS 192.168.0.80
1272 +Data examples - words returned in octal format
1273 +124300 116400 - IP address 192.168.0.157
1274 +177777 000377 - MASK mask 255.255.255.0
1275 +124300 000400 - GW gateway 192.168.0.1
1276 +124300 000400 - NTP address of NTP server 192.168.0.1
1277 +124300 050000 - DNS1 address of primary DNS 192.168.0.90
1278 +124300 055000 - DNS2 address of backup DNS 192.168.0.80
1284 1284  {{/info}}
1285 1285  
1286 -== **043: чтение MAC-адреса в ip буфер** ==
1281 +== 043: Read MAC address into ip buffer ==
1287 1287  
1288 -Код команды 043, данная команда читает текущий фактический MAC адрес в буфер IP адресов
1289 -те сначала 043, а затем 041 команды
1283 +Command code 043, this command reads the current actual MAC address into the IP address buffer i.e. first 043 and then 041 commands
1290 1290  
1291 -Пример программы:
1285 +Example program:
1292 1292  
1293 1293  {{code language="assembler"}}
1294 -; trap 72 - чтение MAC адреса в блок памяти IPADDDBLOCK (12. ячеек)
1295 -; результат в R3 =0 error, иначе адрес куда считано (IPADDDBLOCK)
1296 -GetMACaddrs: push R1
1297 - push R2
1298 - call AZreset ; сбросим
1299 - tst R1
1300 - bne 0ERR$
1301 - MOV #AZ$CSR,R1
1302 - mov #43,(R1)
1303 -0$: TSTB (R1) ; прочитать адреса в свою память
1304 - BPL 0$ ; ждем
1305 - mov #41,(R1)
1306 -1$: TSTB (R1) ; подготовить буфер
1307 - BPL 1$ ; ждем
1308 - TST (R1)+ ; инкрементируем
1309 - mov #IPADDDBLOCK,R3
1310 - mov #12.,R2
1311 -2$: mov (R1),(R3)+ ; читаем блок слов в память
1312 - sob R2,2$
1313 - mov #IPADDDBLOCK,R3; успешно
1314 - br 0END$
1315 -0ERR$: CLR R3
1316 -0END$: pop R2
1317 - pop R1
1318 - retur
1288 +; trap 72 - reading the MAC address into the IPADDDBLOCK memory block (12 cells)
1289 +; result in R3 = 0 if error, otherwise the address where it was read (IPADDDBLOCK)
1290 +GetMACaddrs: push R1
1291 + push R2
1292 + call AZreset ; reset
1293 + tst R1
1294 + bne 0ERR$
1295 + MOV #AZ$CSR,R1
1296 + mov #43,(R1)
1297 +0$: TSTB (R1) ; read addresses into its memory
1298 + BPL 0$ ; wait
1299 + mov #41,(R1)
1300 +1$: TSTB (R1) ; prepare buffer
1301 + BPL 1$ ; wait
1302 + TST (R1)+ ; increment
1303 + mov #IPADDDBLOCK,R3
1304 + mov #12.,R2
1305 +2$: mov (R1),(R3)+ ; read block of words into memory
1306 + sob R2,2$
1307 + mov #IPADDDBLOCK,R3; success
1308 + br 0END$
1309 +0ERR$: CLR R3
1310 +0END$: pop R2
1311 + pop R1
1312 + retur
1313 +
1319 1319  {{/code}}
1320 1320  
1321 1321  
1322 1322  
1323 -= **Команды для работы с MicroSD картой на файловом уровне** =
1318 += Commands for working with a MicroSD card at the file level =
1324 1324  
1325 1325  
1326 -Данные команды предназначены для работы с MicroSD картой на уровне файловой системы и позволяет читать/писать файлы без монтирования файлов как образов дисков.
1321 +These commands are designed to work with a MicroSD card at the file system level and allow you to read/write files without mounting files as disk images.
1327 1327  
1328 -Эти команды используют буфер 256. слов который задействован в интерфейсе работы с энергонезависимой памятью (см выше команды 022 023)
1329 -\\Ограничения - длина полного пути к файлу  256 байт
1323 +These commands use a 256-word buffer that is used in the interface for working with non-volatile memory (see commands 022 023 above)
1330 1330  
1331 -== **050: Установить имя файла который будем читать** ==
1325 +Limitations - the length of the full path to the file is 256 bytes
1332 1332  
1333 -Код команды 050 данная команда устанавливает имя файла который будем читать, при этом производится открытие файла на чтение, а также получение его свойств.
1327 +== 050: Set the name of the file we will read ==
1334 1334  
1335 -== **051: Получить размер файла на чтение (или его статус) на МПИ** ==
1329 +Command code 050, this command sets the name of the file that we will read, while opening the file for reading, and also obtaining its properties.
1336 1336  
1337 -Код команды 051 данная команда передает на МПИ размер файла или ошибку его чтения. Размер файла 31бит, старший бит является признаком ошибки. Соответственно максимальный размер файлов с которыми можно работать через этот интерфейс ограничен 2^31 байт (2GB).
1331 +== 051: Get file size for reading (or its status) on BUS ==
1338 1338  
1339 -формирование ошибки выглядит так:
1340 -sizeanyfile=1<<31 + FFres; ~/~/ если установлен старший бит 32х битного слова - то в младшей части код ошибки
1341 -\\FFres = ошибка FatFS
1342 -
1333 +Command code 051, this command transmits the file size or reading error to the MPI. The file size is 31 bits, the most significant bit is an error indicator. Accordingly, the maximum file size that can be worked with via this interface is limited to 2 ^ 31 bytes (2GB).
1343 1343  
1335 +The error generation looks like this:
1336 +sizeanyfile=1<<31 + FFres; ~/~/ if the most significant bit of a 32-bit word is set, then the error code is in the lower part
1337 +
1338 +FFres = FatFS error
1339 +
1344 1344  {{code language="c"}}
1345 1345  typedef enum {
1346 1346   FR_OK = 0, /* (0) Succeeded */
... ... @@ -1368,317 +1368,309 @@
1368 1368  
1369 1369  [[http:~~/~~/elm-chan.org/fsw/ff/doc/open.html>>url:http://elm-chan.org/fsw/ff/doc/open.html]]
1370 1370  
1371 -== **052: Читать блок установленного файла в буфер** ==
1367 +== 052: Read a block of a set file into a buffer ==
1372 1372  
1373 -Код команды 052,  данная команда осуществляет чтение файла в буфер энергонезависимой памяти.
1369 +Command code 052, this command reads a file into a non-volatile memory buffer.
1374 1374  
1375 -В итоге схема чтения файла выглядит вот так
1376 -**023** - заливаем имя файла в буфер
1377 -**050** - устанавливаем файл на чтение
1378 -**051 **- читаем длину файла или ошибку открытия файла
1379 -если ошибка - повторяем сначала 023 050 051
1380 -если все ok - приступаем к чтению файла
1381 -**052** - читает блок файла в буфер
1382 -**022 **- забираем данные из буфера
1383 -пары 052 022 повторяем нужное количество раз дабы считать весь файл
1384 -как файл будет прочтен - последняя 052 команда закроет его автоматически.
1385 -
1371 +As a result, the file reading scheme looks like this
1372 +**023** - fill the file name into the buffer
1373 +**050 **- set the file for reading
1374 +**051** - read the file length or file open error
1375 +if there is an error - repeat 023 050 051 from the beginning
1376 +if everything is ok - start reading the file
1377 +**052** - read the file block into the buffer
1378 +**022** - take data from the buffer
1379 +repeat the **052 022** pairs the required number of times in order to read the entire file
1380 +once the file is read - the last 052 command will close it automatically.
1386 1386  
1387 -Пример программы
1382 +Example program:
1388 1388  
1389 1389  {{code language="assembler"}}
1385 + call AZRST; reset
1390 1390  
1391 - call AZRST; сбросим
1387 +; load the file name into the buffer
1388 +7$: mov #23,(R1); command to write data to the buffer
1389 +5$: TSTB (R1); check execution result
1390 + BPL 5$ ; wait
1391 + TST (R1)+; increment
1392 + mov #FILNM,R3
1393 +1$: mov (R3),(R1); send to controller
1394 + tst (R3)+
1395 + bne 1$
1396 + tst -(R1); decrement
1392 1392  
1393 -; заливаем в буфер имя файла
1394 -7$: mov #23,(R1); командуем что будем писать данные в буфер
1395 -5$: TSTB (R1); проверяем результат выполнения
1396 - BPL 5$ ; ждем
1397 - TST (R1)+; инкрементируем
1398 - mov #FILNM,R3
1399 -1$: mov (R3),(R1); отдаем в контроллер
1400 - tst (R3)+
1401 - bne 1$
1402 - tst -(R1); декрементируем
1398 +; set the file for reading
1399 + mov #50,(R1); set file for reading
1400 +2$: TSTB (R1); check execution result
1401 + BPL 2$ ; wait
1403 1403  
1403 +; read the file length
1404 + mov #51,(R1); set file for reading
1405 +3$: TSTB (R1); check execution result
1406 + BPL 3$ ; wait
1407 + TST (R1)+; increment
1408 + mov #FILSZ,R3
1409 + mov (R1),(R3)+; read from controller
1410 + mov (R1),(R3); read from controller
1404 1404  
1405 - ; устанавливаем файл на чтение
1406 - mov #50,(R1); устанавливаем файл на чтение
1407 -2$: TSTB (R1); проверяем результат выполнения
1408 - BPL 2$ ; ждем
1412 +; display the file length on the screen
1413 + clr R0
1414 + mov #FILSZ+2,R3
1415 + mov (R3),R1
1416 + call DNOZ
1417 + mov -(R3),R1
1418 + call DNOZ
1419 + .print #STMS2
1409 1409  
1421 +; read the file
1422 + mov R1,R4; R1 holds the file length
1423 + MOV #AZ$CSR,R1
1424 + mov #BUFFL,R5
1410 1410  
1411 - ; читаем длину файда
1412 - mov #51,(R1); устанавливаем файл на чтение
1413 -3$: TSTB (R1); проверяем результат выполнения
1414 - BPL 3$ ; ждем
1415 - TST (R1)+; инкрементируем
1416 - mov #FILSZ,R3
1417 - mov (R1),(R3)+; читаем с контроллера
1418 - mov (R1),(R3); читаем с контроллера
1426 + bit #1,R4; if an odd number of bytes
1427 + beq 47$
1428 + inc R4; add 1 more byte as we read words
1419 1419  
1420 - ; выведем длину файла на экран
1421 - clr R0
1422 - mov #FILSZ+2,R3
1423 - mov (R3),R1
1424 - call DNOZ
1425 - mov -(R3),R1
1426 - call DNOZ
1427 - .print #STMS2
1430 +47$: tst R4
1431 + beq 45$ ; nothing left to read - exit
1428 1428  
1429 - ; читаем файл
1430 - mov R1,R4; в R1 осталась длина файла
1431 - MOV #AZ$CSR,R1
1432 - mov #BUFFL,R5
1433 + mov #52,(R1); read block into buffer
1434 +4$: TSTB (R1); check execution result
1435 + BPL 4$ ; wait
1436 + mov #22,(R1); start reading buffer
1437 +51$: TSTB (R1); check execution result
1438 + BPL 51$ ; wait
1433 1433  
1434 - bit #1,R4; если нечетное число байт
1435 - beq 47$
1436 - inc R4; добавим еще 1 байт тк читаем словами
1440 + cmp R4,#512.; compare with buffer size in bytes
1441 + Blos 44$ ; less than buffer size left
1437 1437  
1438 -47$: tst R4
1439 - beq 45$ ; уже нечего читать - выходим
1443 + .print #STMS1
1444 + mov #256.,R2
1445 + TST (R1)+; move to data register
1446 +46$: mov (R1),(R5)+; read into buffer
1447 + sob R2,46$
1448 + sub #512.,R4; subtract
1449 + TST -(R1); move to command register
1450 + br 47$
1440 1440  
1452 +44$: .print #STMS3
1453 + mov R4,R2
1454 + asr R2 ; /2 since reading words
1455 + TST (R1)+; move to data register
1456 +43$: mov (R1),(R5)+; read into buffer
1457 + sob R2,43$
1441 1441  
1442 - mov #52,(R1); читаем блок в буфер
1443 -4$: TSTB (R1); проверяем результат выполнения
1444 - BPL 4$ ; ждем
1445 - mov #22,(R1); будем читать буфер
1446 -51$: TSTB (R1); проверяем результат выполнения
1447 - BPL 51$ ; ждем
1459 +45$: clr (R5); set end of file marker
1448 1448  
1449 - cmp R4,#512.; сравниваем c размером буфера в байтах
1450 - Blos 44$ ; осталось меньше чем буфер
1461 +; file read - display on screen
1462 + .print #STMS4
1463 + .print #BUFFL
1464 + .print #STMS5
1451 1451  
1466 + mov #110,@#AZ$CSR; enable network
1467 + .Exit
1452 1452  
1453 - .print #STMS1
1454 - mov #256.,R2
1455 - TST (R1)+; переходим на регистр данных
1456 -46$: mov (R1),(R5)+; читаем в буфер
1457 - sob R2,46$
1458 - sub #512.,R4; вычитаем
1459 - TST -(R1); переходим на регистр команд
1460 - br 47$
1461 -
1462 -44$: .print #STMS3
1463 - mov R4,R2
1464 - asr R2 ; /2 тк читаем словами
1465 - TST (R1)+; переходим на регистр данных
1466 -43$: mov (R1),(R5)+; читаем в буфер
1467 - sob R2,43$
1468 -
1469 -
1470 -45$: clr (R5); проставим конец файла
1471 - ; файл считан - выводим на экран
1472 - .print #STMS4
1473 - .print #BUFFL
1474 - .print #STMS5
1475 -
1476 -
1477 - mov #110,@#AZ$CSR; включаем сеть
1478 - .Exit
1479 1479  {{/code}}
1480 1480  
1481 1481  
1482 1482  
1483 -== **053:** установить имя файла который будем писать ==
1473 +== 053: set the name of the file that we will write ==
1484 1484  
1485 -Код команды 053,  данная команда открывает файл на запись, получает параметры открытия (или ошибки).
1475 +Command code 053, this command opens a file for writing, receives opening parameters (or errors).
1486 1486  
1487 -== **054:** установка длины файла ==
1477 +== 054: Set file length ==
1488 1488  
1489 -Код команды 054,  данная команда устанавливает ожидаемую длину файла, это нужно для корректного формирования файла на файловом уровне MicroSD карты, а также для организации передачи данных.
1479 +Command code 054, this command sets the expected file length, this is necessary for the correct formation of the file at the file level of the MicroSD card, as well as for organizing data transfer.
1490 1490  
1491 -== **055:** записать в файл данные из буфера ==
1481 +== 055: write data from buffer to file ==
1492 1492  
1493 -Код команды 055,  данная команда записывает в открытый файл на запись данные из буфера энергонезависимой памяти. Последняя команда 055 автоматически закроет файл по достижению заявленной длины файла.
1483 +Command code 055, this command writes data from the non-volatile memory buffer to an open file for writing. The last command 055 will automatically close the file when the declared file length is reached.
1494 1494  
1495 -Схема подачи команд при записи вот такая
1496 -**023** - заливаем имя файла в буфер
1497 -**053** - устанавливаем файл на чтение
1498 -**051 **- статус открытия/создания файла
1499 -если ошибка - повторяем сначала 023 053 051
1500 -если все ok - идем дальше
1501 -**054** - установка длины файла, те надо сразу объявить какая у нас будет длина файла
1502 -**023** - заливаем блок данных в буфер
1503 -**055** - пишем из буфера в файл
1504 -пары 023 055 повторяем нужное количество раз дабы записать весь файл
1505 -как файл будет записан - последняя 055 команда закроет его автоматически
1485 +The command flow chart for writing is as follows
1486 +**023** - fill the file name into the buffer
1487 +**053** - set the file for reading
1488 +**051** - file opening/creation status
1489 +if an error - repeat from the beginning 023 053 051
1490 +if everything is ok - move on
1491 +**054** - set the file length, i.e. we must immediately declare what the file length will be
1492 +**023** - fill the data block into the buffer
1493 +**055** - write from the buffer to the file
1494 +repeat the 023 055 pairs the required number of times in order to write the entire file
1495 +once the file is written - the last 055 command will close it automatically
1506 1506  
1507 1507  
1508 -Пример программы:
1498 +Example program:
1509 1509  
1510 1510  {{code language="assembler"}}
1511 -; заливаем в буфер имя файла
1512 - MOV #AZ$CSR,R1
1513 -17$: mov #23,(R1); командуем что будем писать данные в буфер
1514 -15$: TSTB (R1) ; проверяем результат выполнения
1515 - BPL 15$ ; ждем
1516 - TST (R1)+ ; переходим на регистр данных
1517 - mov #FILNM2,R3
1518 -11$: mov (R3),(R1); отдаем в контроллер
1519 - tst (R3)+
1520 - bne 11$
1521 - tst -(R1) ; переходим на регистр команд
1501 +; load the file name into the buffer
1502 + MOV #AZ$CSR,R1
1503 +17$: mov #23,(R1); command to write data to the buffer
1504 +15$: TSTB (R1) ; check execution result
1505 + BPL 15$ ; wait
1506 + TST (R1)+ ; move to data register
1507 + mov #FILNM2,R3
1508 +11$: mov (R3),(R1); send to controller
1509 + tst (R3)+
1510 + bne 11$
1511 + tst -(R1) ; move to command register
1522 1522  
1523 - ; устанавливаем файл на запись
1524 - mov #53,(R1); устанавливаем файл на запись
1525 -12$: TSTB (R1) ; проверяем результат выполнения
1526 - BPL 12$ ; ждем
1513 +; set the file for writing
1514 + mov #53,(R1); set file for writing
1515 +12$: TSTB (R1) ; check execution result
1516 + BPL 12$ ; wait
1527 1527  
1518 +; read file creation status
1519 + mov #51,(R1)
1520 +13$: TSTB (R1) ; check execution result
1521 + BPL 13$ ; wait
1522 + TST (R1)+ ; move to data register
1523 + mov #STATS,R3
1524 + mov (R1),(R3)+; read from controller
1525 + mov (R1),(R3); read from controller
1528 1528  
1529 - ; читаем статус создания файла
1530 - mov #51,(R1)
1531 -13$: TSTB (R1) ; проверяем результат выполнения
1532 - BPL 13$ ; ждем
1533 - TST (R1)+ ; переходим на регистр данных
1534 - mov #STATS,R3
1535 - mov (R1),(R3)+; читаем с контроллера
1536 - mov (R1),(R3); читаем с контроллера
1527 +; check here - if the file is created, both words should be zero
1528 + mov #STATS,R3
1529 + TST (R3)+
1530 + BNE 66$
1531 + TST (R3)
1532 + BEQ 60$
1533 +66$: .print #ERRMS1 ; print error
1534 + .exit
1537 1537  
1538 - ; тут надо проверить - если файл создан то оба слова нулевые
1539 - mov #STATS,R3
1540 - TST (R3)+
1541 - BNE 66$
1542 - TST (R3)
1543 - BEQ 60$
1544 -66$: .print #ERRMS1 ; печать ошибки
1545 - .exit
1536 +60$: MOV #AZ$CSR,R1
1537 + mov #54,(R1); set file length to be written
1538 +23$: TSTB (R1) ; check execution result
1539 + BPL 23$ ; wait
1540 + TST (R1)+ ; move to data register
1541 + mov #FILSZ,R3
1542 + mov (R3)+,(R1); write to controller
1543 + mov (R3),(R1); write to controller
1546 1546  
1547 -60$: MOV #AZ$CSR,R1
1548 - mov #54,(R1); установим длину файла который будем писать
1549 -23$: TSTB (R1) ; проверяем результат выполнения
1550 - BPL 23$ ; ждем
1551 - TST (R1)+ ; переходим на регистр данных
1552 - mov #FILSZ,R3
1553 - mov (R3)+,(R1); пишем в контроллер
1554 - mov (R3),(R1); пишем в контроллер
1545 + tst -(R1) ; move to command register
1555 1555  
1556 - tst -(R1) ; переходим на регистр команд
1547 +; write file
1548 + mov @#FILSZ,R4; file length
1549 + MOV #AZ$CSR,R1
1550 + mov #BUFFL,R5; file buffer
1557 1557  
1552 + bit #1,R4 ; if an odd number of bytes
1553 + beq 147$
1554 + inc R4 ; add 1 more byte since reading words
1558 1558  
1556 +147$: tst R4 ; check length
1557 + beq 145$ ; nothing left to write - exit
1559 1559  
1560 - ; пишем файл
1561 - mov @#FILSZ,R4; длина файла
1562 - MOV #AZ$CSR,R1
1563 - mov #BUFFL,R5; буфер файла
1559 + mov #23,(R1); write to buffer
1560 +151$: TSTB (R1) ; check execution result
1561 + BPL 151$ ; wait
1564 1564  
1565 - bit #1,R4 ; если нечетное число байт
1566 - beq 147$
1567 - inc R4 ; добавим еще 1 байт тк читаем словами
1563 + cmp R4,#512.; compare with buffer size in bytes
1564 + Blos 144$ ; less than buffer size left
1568 1568  
1569 -147$: tst R4 ; проверим длину
1570 - beq 145$ ; уже нечего писать - выходим
1566 + .print #STMS6 ; writing full block
1567 + mov #256.,R2
1568 + TST (R1)+ ; move to data register
1569 +146$: mov (R5)+,(R1); write to controller buffer
1570 + sob R2,146$
1571 + sub #512.,R4; subtract
1572 + TST -(R1) ; move to command register
1571 1571  
1572 - mov #23,(R1); будем писать в буфер
1573 -151$: TSTB (R1) ; проверяем результат выполнения
1574 - BPL 151$ ; ждем
1574 + mov #55,(R1); write buffer to file
1575 +104$: TSTB (R1) ; check execution result
1576 + BPL 104$ ; wait
1577 + br 147$ ; loop back
1575 1575  
1576 - cmp R4,#512.; сравниваем c размером буфера в байтах
1577 - Blos 144$ ; осталось меньше чем буфер
1579 +144$: .print #STMS7 ; writing last block
1580 + TST (R1)+ ; move to data register
1581 + mov R4,R2
1582 + asr R2 ; /2 since writing words
1583 +143$: mov (R5)+,(R1); write to controller buffer
1584 + sob R2,143$
1578 1578  
1579 - .print #STMS6 ; заливка полного блока
1580 - mov #256.,R2
1581 - TST (R1)+ ; переходим на регистр данных
1582 -146$: mov (R5)+,(R1); пишем в буфер контроллера
1583 - sob R2,146$
1584 - sub #512.,R4; вычитаем
1585 - TST -(R1) ; переходим на регистр команд
1586 + TST -(R1) ; move to command register
1587 + mov #55,(R1); write last buffer to file
1588 +105$: TSTB (R1) ; check execution result
1589 + BPL 105$ ; wait
1586 1586  
1587 - mov #55,(R1); запись буфера в файл
1588 -104$: TSTB (R1) ; проверяем результат выполнения
1589 - BPL 104$ ; ждем
1590 - br 147$ ; в начало
1591 +145$: .print #STMSE ; end
1592 + mov #110,@#AZ$CSR; enable network
1593 + .Exit ; exit
1591 1591  
1592 -144$: .print #STMS7 ; заливка последнего блока
1593 - TST (R1)+ ; переходим на регистр данных
1594 - mov R4,R2
1595 - asr R2 ; /2 тк пишем словами
1596 -143$: mov (R5)+,(R1); пишем в буфер контроллера
1597 - sob R2,143$
1598 -
1599 - TST -(R1) ; переходим на регистр команд
1600 - mov #55,(R1); запись пследнего буфера в файл
1601 -105$: TSTB (R1) ; проверяем результат выполнения
1602 - BPL 105$ ; ждем
1603 -
1604 -145$: .print #STMSE ; конец
1605 - mov #110,@#AZ$CSR; включаем сеть
1606 - .Exit ; выходим
1607 1607  {{/code}}
1608 1608  
1609 -**[[пример полностью в виде утилиты RT11 выложен вот тут>>url:https://forum.maxiol.com/index.php?s=&showtopic=5605&view=findpost&p=57055]]**
1597 +**[[the example is completely in the form of the RT11 utility and is posted here>>url:https://forum.maxiol.com/index.php?s=&showtopic=5605&view=findpost&p=57055]]**
1610 1610  
1611 1611  
1612 -== **056: Получить данные по размеру карты в буфер sizecard** ==
1600 +== 056: Get data on the size of the map into the sizecard buffer ==
1613 1613  
1614 -Код команды 056,  данная команда читает параметры MicroSD карты в буфер sizecard
1602 +Command code 056, this command reads the parameters of the MicroSD card into the sizecard buffer
1615 1615  
1616 -== **057: Чтение буфера sizecard** ==
1604 +== 057: Reading sizecard buffer ==
1617 1617  
1618 -Код команды 057,  данная команда отдает буфер sizecard (2 слова)
1606 +Command code 057, this command returns the sizecard buffer (2 words)
1619 1619  
1620 -буфер sizecard содержит 2 слова 16bit
1621 -первое слово - общий объем карты доступный для FAT в МБ
1622 -второе слово - свободный объем на карте в МБ
1608 +sizecard buffer contains 2 words 16bit
1609 +first word - total card size available for FAT in MB
1610 +second word - free card size in MB
1623 1623  
1624 -Пример программы:
1612 +Example program:
1625 1625  
1626 1626  {{code language="assembler"}}
1627 -; trap 51 - получение объема SD карты всего/свободно в мегабайтах
1628 -; результат в R1 - всего; R2 - свободно
1629 -GetSizeSD: call AZreset; сбросим
1630 - tst R1
1631 - bne 0ERR$
1632 - MOV #AZ$CSR,R1
1633 - mov #56,(R1)
1634 -1$: TSTB (R1); подготовить буфер
1635 - BPL 1$; ждем
1636 - mov #57,(R1)
1637 -2$: TSTB (R1); подготовить буфер
1638 - BPL 2$; ждем
1639 - mov @#AZ$DR ,R1; всего мегабайт
1640 - mov @#AZ$DR ,R2; свободно мегабайт
1641 - return
1642 - clr R1
1643 - clr R2
1644 - return
1615 +; trap 51 - get the total/free size of the SD card in megabytes
1616 +; result in R1 - total; R2 - free
1617 +GetSizeSD: call AZreset ; reset
1618 + tst R1
1619 + bne 0ERR$
1620 + MOV #AZ$CSR,R1
1621 + mov #56,(R1)
1622 +1$: TSTB (R1) ; prepare buffer
1623 + BPL 1$ ; wait
1624 + mov #57,(R1)
1625 +2$: TSTB (R1) ; prepare buffer
1626 + BPL 2$ ; wait
1627 + mov @#AZ$DR ,R1 ; total megabytes
1628 + mov @#AZ$DR ,R2 ; free megabytes
1629 + return
1630 + clr R1
1631 + clr R2
1632 + return
1633 +
1645 1645  {{/code}}
1646 1646  
1647 -Пример данных
1648 -035521 - всего на карточке мегабайт - 15185.
1649 -035417 - свободно мегабайт - 15119.
1650 -
1636 +Example data
1637 +035521 - total megabytes on the card - 15185.
1638 +035417 - free megabytes - 15119.
1651 1651  
1652 -= **Блок команд API Hall of Fame** =
1640 += Hall of Fame API Command Block =
1653 1653  
1654 -Данный блок команд предназначен для взаимодействия с сервером [[Hall of Fame>>https://forum.maxiol.com/index.php?showtopic=5642]]
1642 +This block of commands is intended for interaction with the server [[Hall of Fame>>https://forum.maxiol.com/index.php?showtopic=5642]]
1655 1655  
1656 1656  == **025: Инициализация Hall of Fame (HOF)** ==
1657 1657  
1658 -Код команды 025,  данная команда устанавливает соединение с сервером Hall of Fame, инициализирует шифрованный тоннель и подготавливает API к работе.
1646 +Command code 025, this command establishes a connection to the Hall of Fame server, initializes the encrypted tunnel and prepares the API for work.
1659 1659  
1660 -Пример программы
1648 +Example program:
1661 1661  
1662 1662  {{code language="assembler"}}
1663 -AZ$CSR = 177220 ; регистр команд и состояния (CSR)
1664 -AZ$DR = 177222 ; регистр данных (DR)
1651 +AZ$CSR = 177220 ; command and status register (CSR)
1652 +AZ$DR = 177222 ; data register (DR)
1665 1665  
1666 -; буфера
1667 -SNDBUF: .BLKW 256. ; буфер передачи
1668 -RCVBUF: .BLKW 256. ; буфер приема ответа
1654 +; buffers
1655 +SNDBUF: .BLKW 256. ; send buffer
1656 +RCVBUF: .BLKW 256. ; receive buffer
1669 1669  SIDMEM: .BLKB 34. ; SID
1670 -SIDCST: .ASCII \{"SID":"\ ; заголовок SID
1658 +SIDCST: .ASCII \{"SID":"\ ; SID header
1671 1671   .even
1672 1672  
1673 -HOFINI: ; инициализация HOF
1674 - ;результатом является такой JSON
1675 - ;{"SID":"хеш сессии","RESULT":"OK"}
1676 - ;или ошибка
1677 - ;{"RESULT":"ERROR","DESCRIPTION":"SERVER_ERROR"}
1678 - ;{"RESULT":"ERROR","DESCRIPTION":"CONNECTION_ERROR"}
1679 - ; результат помещается в SNDBUF
1680 - ; в R5 фиксация успешности - =1 есть SID, =0 нет SID
1681 -
1661 +HOFINI: ; HOF initialization
1662 + ; The result is a JSON response:
1663 + ; {"SID":"session hash","RESULT":"OK"}
1664 + ; or an error:
1665 + ; {"RESULT":"ERROR","DESCRIPTION":"SERVER_ERROR"}
1666 + ; {"RESULT":"ERROR","DESCRIPTION":"CONNECTION_ERROR"}
1667 + ; The result is placed in SNDBUF
1668 + ; R5 indicates success: 1 = SID exists, 0 = no SID
1669 +
1682 1682   mov R5, -(SP)
1683 1683   mov R4, -(SP)
1684 1684   mov R3, -(SP)
... ... @@ -1686,29 +1686,29 @@
1686 1686   mov R1, -(SP)
1687 1687   mov R0, -(SP)
1688 1688  
1689 - mov #3,R5 ; количество попыток
1677 + mov #3,R5 ; number of attempts
1690 1690  
1691 1691  220$: mov #AZ$CSR,R1
1692 - clr (R1) ; Пошлем команду "Сброс"
1693 -221$: tstb (R1) ; Проверим готовность контроллера
1694 - bpl 221$ ; Если не готов ждем
1680 + clr (R1) ; Send "Reset" command
1681 +221$: tstb (R1) ; Check controller readiness
1682 + bpl 221$ ; If not ready, wait
1695 1695  
1696 - mov #25,(R1) ; инициализация - команда 025
1697 -20$: tstb (R1) ; проверяем результат выполнения
1698 - bpl 20$ ; ждем
1684 + mov #25,(R1) ; initialization - command 025
1685 +20$: tstb (R1) ; check execution result
1686 + bpl 20$ ; wait
1699 1699  
1700 - ; получим результат
1701 - mov #22,(R1) ; отдать на шину считанный блок памяти из буфера
1702 -21$: tstb (R1) ; проверяем результат выполнения
1703 - bpl 21$ ; ждем
1704 - tst (R1)+ ; инкрементируем
1688 + ; Retrieve the result
1689 + mov #22,(R1) ; output the read memory block from buffer to the bus
1690 +21$: tstb (R1) ; check execution result
1691 + bpl 21$ ; wait
1692 + tst (R1)+ ; increment
1705 1705   mov #SNDBUF,R3
1706 - mov #256.,R2 ; читаем 256. слов; первое слово - результат чтения
1707 -22$: mov (R1),(R3)+ ; читаем блок слов в память
1694 + mov #256.,R2 ; read 256 words; first word is the read result
1695 +22$: mov (R1),(R3)+ ; read block of words into memory
1708 1708   sob R2,22$
1709 1709  
1710 1710  
1711 - ; надо понять - есть ли SID
1699 + ; Determine if SID exists
1712 1712   mov #4,R0
1713 1713   mov #SNDBUF,R1
1714 1714   mov #SIDCST,R2
... ... @@ -1717,11 +1717,11 @@
1717 1717   sob R0,23$
1718 1718   clr R5
1719 1719   inc R5
1720 - br 26$ ; успешно
1708 + br 26$ ; success
1721 1721  
1722 -24$: ; SID не найден!
1710 +24$: ; SID not found!
1723 1723   sob R5,220$
1724 - clr R5 ; ошибка - нет SID
1712 + clr R5 ; error - no SID
1725 1725  
1726 1726  26$: mov (SP)+, R0
1727 1727   mov (SP)+, R1
... ... @@ -1730,69 +1730,71 @@
1730 1730   mov (SP)+, R4
1731 1731   mov (SP)+, R5
1732 1732   return
1721 +
1733 1733  {{/code}}
1734 1734  
1735 -== **026: обмен с Hall of Fame (HOF)** ==
1724 +== 026: Exchange with Hall of Fame (HOF) ==
1736 1736  
1737 -Код команды 026,  данная команда осуществляет непосредственный обмен с Hall of Fame
1726 +Command code 026, this command makes a direct exchange with Hall of Fame
1738 1738  
1739 -Пример программы
1728 +Example program:
1740 1740  
1741 1741  {{code language="assembler"}}
1742 - ;4. авторизация пользователя
1743 - ;технически это отправка JSON
1744 - ;{"SID":"хеш сессии","CMD":"AUTH_USER","NIKNAME":"никнейм пользователя","PASSWORD":"пароль пользователя"}
1745 - ;ответ тоже JSON
1746 - ;{"SID":"хеш сессии","RESULT":"OK","UID":"хеш пользователя"}
1747 - ;или
1748 - ;{"SID":"хеш сессии","RESULT":"ERROR","DESCRIPTION":"USER_NOT_FOUND_OR_WRONG_PASSWORD"}
1749 - ;{"SID":"хеш сессии","RESULT":"ERROR","DESCRIPTION":"SERVER_ERROR"}
1750 - ;{"SID":"хеш сессии","RESULT":"ERROR","DESCRIPTION":"SESSION_NOT_EXISTS_OR_EXPIRED"}
1731 + ;4. user authentication
1732 + ;technically, this is sending a JSON
1733 + ;{"SID":"session hash","CMD":"AUTH_USER","NIKNAME":"user nickname","PASSWORD":"user password"}
1734 + ;the response is also JSON
1735 + ;{"SID":"session hash","RESULT":"OK","UID":"user hash"}
1736 + ;or
1737 + ;{"SID":"session hash","RESULT":"ERROR","DESCRIPTION":"USER_NOT_FOUND_OR_WRONG_PASSWORD"}
1738 + ;{"SID":"session hash","RESULT":"ERROR","DESCRIPTION":"SERVER_ERROR"}
1739 + ;{"SID":"session hash","RESULT":"ERROR","DESCRIPTION":"SESSION_NOT_EXISTS_OR_EXPIRED"}
1751 1751  
1752 - ; загоняем команду CMD04
1753 - mov #CMD04,R1
1754 - mov #ADRMEM,R2
1755 - add #42.,R2 ; cдвигаем указатель на длину блока с SID
1756 -33$: movb (R1)+,(R2)+
1757 - bne 33$
1741 + ; load command CMD04
1742 + mov #CMD04,R1
1743 + mov #ADRMEM,R2
1744 + add #42.,R2 ; shift the pointer to the SID block length
1745 +33$: movb (R1)+,(R2)+
1746 + bne 33$
1758 1758  
1759 - .Print #ADRMEM
1748 + .Print #ADRMEM
1760 1760  
1761 - .Print #HOF05
1762 - ; отсылаем команду и ждем ответа
1763 - ; закачиваем в буфер
1764 - MOV #AZ$CSR,R1
1765 -331$: TSTB (R1) ; Проверим готовность контроллера
1766 - BPL 331$ ; Если не готов ждем
1767 - mov #23,(R1) ; командуем что будем писать данные в буфер
1768 -34$: TSTB (R1) ; проверяем результат выполнения
1769 - BPL 34$ ; ждем
1770 - TST (R1)+ ; инкрементируем
1771 - mov #ADRMEM,R3
1772 - mov #256.,R2 ;
1773 -35$: mov (R3)+,(R1) ; отдаем в контроллер
1774 - sob R2,35$
1775 - tst -(R1) ; декрементируем
1750 + .Print #HOF05
1751 + ; send the command and wait for a response
1752 + ; load into buffer
1753 + MOV #AZ$CSR,R1
1754 +331$: TSTB (R1) ; Check controller readiness
1755 + BPL 331$ ; If not ready, wait
1756 + mov #23,(R1) ; command to write data into buffer
1757 +34$: TSTB (R1) ; check execution result
1758 + BPL 34$ ; wait
1759 + TST (R1)+ ; increment
1760 + mov #ADRMEM,R3
1761 + mov #256.,R2 ;
1762 +35$: mov (R3)+,(R1) ; send to controller
1763 + sob R2,35$
1764 + tst -(R1) ; decrement
1776 1776  
1777 - ; обмен - команда 026
1778 - MOV #AZ$CSR,R1
1779 -361$: TSTB (R1) ; Проверим готовность контроллера
1780 - BPL 361$ ; Если не готов ждем
1781 - mov #26,(R1)
1782 -36$: TSTB (R1) ; проверяем результат выполнения
1783 - BPL 36$ ; ждем
1766 + ; exchange - command 026
1767 + MOV #AZ$CSR,R1
1768 +361$: TSTB (R1) ; Check controller readiness
1769 + BPL 361$ ; If not ready, wait
1770 + mov #26,(R1)
1771 +36$: TSTB (R1) ; check execution result
1772 + BPL 36$ ; wait
1784 1784  
1785 - ; получим результат
1786 -371$: TSTB (R1) ; Проверим готовность контроллера
1787 - BPL 371$ ; Если не готов ждем
1788 - mov #22,(R1) ; отдать на шину буфер
1789 -37$: TSTB (R1) ; проверяем результат выполнения
1790 - BPL 37$ ; ждем
1791 - TST (R1)+ ; инкрементируем
1792 - mov #ADRMEM,R3
1793 - mov #256.,R2 ; читаем 256. слов; первое слово - результат чтения
1794 -38$: mov (R1),(R3)+ ; читаем блок слов в память
1795 - sob R2,38$
1774 + ; receive result
1775 +371$: TSTB (R1) ; Check controller readiness
1776 + BPL 371$ ; If not ready, wait
1777 + mov #22,(R1) ; send buffer to the bus
1778 +37$: TSTB (R1) ; check execution result
1779 + BPL 37$ ; wait
1780 + TST (R1)+ ; increment
1781 + mov #ADRMEM,R3
1782 + mov #256.,R2 ; read 256 words; first word is the read result
1783 +38$: mov (R1),(R3)+ ; read block of words into memory
1784 + sob R2,38$
1785 +
1796 1796  {{/code}}
1797 1797  
1798 1798