Changes for page API контроллеров AZ®

Summary

• Page properties (1 modified, 0 added, 0 removed)

Details

Page properties

Content

...	...	@@ -480,49 +480,49 @@
480	480	{{code language="assembler"}}
481	481	;..................................
482	482
483		-WrBuf=016; Символическое наименование команды
	483	+WrBuf=016; Symbolic name of the command
484	484
485		-; Перед записью нужно выполнить те же действия, что и в
486		-; пп. 3.1.-3.3. Обычно, это одна и та же программа,
487		-; просто после пункта 3.3. выполняется проверка "Что
488		-; требуется: чтение или запись?" и разветвление на
489		-; программу чтения или записи.
	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.
490	490
491		-; После фрагмента в п. 3.3. в R3 остался адрес CSR
492		-; (177220). Будем считать, что в R2 находится адрес в
493		-; памяти ЦП, где находится блок, подлежащий записи.
494		-; Программа получения этого адреса не показана.
	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.
495	495
496		- MOV #400,R1; Готовим счетчик
	496	+ MOV #400,R1; Preparing the counter
497	497
498		- MOV #WrBuf,(R3)+; Перешлем команду в CSR и
499		- ; переключим адрес в R3 на
500		- ; DR
	498	+ MOV #WrBuf,(R3)+; Let's forward the command to the CSR and
	499	+; switch the address in R3 to
	500	+; DR
501	501
502		-4$: MOV (R2)+,@R3; Перешлем очередное слово
503		- ; данных
504		- 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
505	505	;..................................
506	506	{{/code}}
507	507
508		-== **017: Получить размер псевдодиска, большой** ==
	508	+== 017: Get ramdisk size, large ==
509	509
510		-Есть две команды получения размера псевдодиска, т.е. смонтированного на выбранный псевдопривод AZn файл-образа.
511		-\\Если используемая ОС (или программа, работающая с дисками без ОС) умеет работать с большими (больше 32М) дисками, следует пользоваться командой с кодом 017. Последовательность действий: сбросить контроллер (п. 3.1), выбрать накопитель (п. 3.2) и переслать в CSR код 017, а затем, без каких-либо ожиданий, считать из DR сначала младшее, и следом за ним старшее слово размера выбранного накопителя (файл-образа).
512		-\\Если используемая ОС не умеет работать с дисками бОльшими, чем 32М (RT-11), следует пользоваться командой 007 - получить размер псевдодиска с ограничением до 32М. Действия похожие: сбрасываем контроллер, выбираем диск, посылаем в CSR код [[007>>doc:||anchor="H007:41F43E43B44344743844244C44043043743C43544043F44143543243443E43443844143A430"]] и считываем из DR одно слово размера псевдодиска. Если размер файл-образа, смонтированного на выбранный псевдопривод, больше 65534 блоков, вместо этого "большого" размера, контроллер возвращает число 65534. Напоминаем, что число 65535 кое-где используется в специальных целях и не может быть размером диска.
513		-\\Также напоминаем, что если на этот накопитель не смонтирован файл-образ, последовательность действий не пройдет (команда 001 выбор устройства) и исполнение программы до этого места просто не дойдет. Поэтому ошибок у этих команд не предусмотрено.
514		-\\Пример программы с большими дисками
	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
515	515
516	516	{{code language="assembler"}}
517	517	;......................................
518	518
519		-GetBig=017; Получить "большой" размер диска
	519	+GetBig=017; Get the "big" disk size
520	520
521		-; От фрагмента 3.2 (выбор диска) у нас в R3 остался
522		-; адрес DR (177222)
	521	+; From fragment 3.2 (disk selection) we have in R3
	522	+; DR address (177222)
523	523
524		- MOV #GetBig,-(R3); пошлем команду
525		- TST (R3)+; вернем адрес в R3 назад, на DR
	524	+ MOV #GetBig,-(R3); send the command
	525	+ TST (R3)+; return the address in R3 back to DR
526	526	MOV @R3,BigSiz
527	527	MOV @R3,BigSiz+2
528	528	;......................................
...	...	@@ -529,27 +529,26 @@
529	529	{{/code}}
530	530
531	531
532		-== **020: Получить расширенный код диагностики** ==
	532	+== 020: Get extended diagnostic code ==
533	533
534		-Код команды 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.
535	535
536	536
537		-== **027: Получить версию firmware AZ STM32** ==
	537	+== 027: Get firmware version AZ STM32 ==
538	538
539		-Код команды 027, возвращает 2 слова
540		-\\первое слово - 06404 = старший байт 13. это версия прошивки, младший байт 4. это версия железа - те AZБК в данном случае
541		-второе слово - 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.
542	542
543	543
544	544	{{code language="assembler"}}
545	545	;-------------------------------------------------------------
546		-; получение версии прошивки STM32 - результат в R1 R1=0 ошибка
	545	+; getting STM32 firmware version - result in R1 R1=0 error
547	547	GTSTMV: MOV #AZ$CSR,R1
548		-1$: CLR (R1) ; Пошлем команду "Сброс"
549		- TSTB (R1) ; Проверим готовность контроллера
550		- BPL 1$ ; Если не готов, сбрасываем еще
	547	+1$: CLR (R1) ; Send "Reset" command
	548	+ TSTB (R1) ;Check controller readinessконтроллера
	549	+ BPL 1$ ; If not ready, reset again
551	551	mov #27,(R1)
552		- TST (R1)+ ; Проверяем на ошибку
	551	+ TST (R1)+ ; Check for error
553	553	BMI 2$
554	554	mov (R1),R1
555	555	return
...	...	@@ -559,45 +559,45 @@
559	559	{{/code}}
560	560
561	561
562		-== **030:  Нет операции** ==
	561	+== 030: No operation ==
563	563
564		-Основное назначение этой команды - устанавливать бит разрешения прерываний от контроллера. Команда передает бит разрешения прерывания, который находится с ней в одном слове, но не входит в ее состав (напоминаем, команда располагается в битах D0 - D5, а бит разрешения прерываний - D6), в соответствующий триггер контроллера и больше никак не влияет на процессы в контроллере. Управление этим триггером работает даже в состоянии "Думаю, прошу не мешать", и это главная особенность команды "нет операции".
565		-\\Команда имеет код 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.
566	566
567	567
568		-= **Блок команд работы с энергонезависимой памятью** =
	567	+= Command block for working with non-volatile memory =
569	569
570		-Интерфейс предоставляет любому 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.
571	571
572		-Все команды этого блока используют буфер энергонезависимой памяти для своей работы.
	571	+All commands in this block use a non-volatile memory buffer for their operation.
573	573
574		-== **021: Cчитать блок энергонезависимой памяти в буфер** ==
	573	+== 021: Read non-volatile memory block into buffer ==
575	575
576	576	(% class="wikigeneratedid" %)
577		-Код команды 021, данная команда вызывает чтение блока энергонезависимой памяти в буфер энергонезависимой памяти.
	576	+Command code 021, this command causes a block of non-volatile memory to be read into the non-volatile memory buffer.
578	578
579	579
580		-== **022: Отдать на шину считанный блок энергонезависимой памяти из буфера** ==
	579	+== 022: Transfer the read block of non-volatile memory from the buffer to the bus ==
581	581
582	582	(% class="wikigeneratedid" %)
583		-Код команды 022, данная команда обеспечивает передачу буфера энергонезависимой памяти в регистр DR для считывания.
	582	+Command code 022, this command ensures that the non-volatile memory buffer is transferred to the DR register for reading.
584	584
585	585	(% class="wikigeneratedid" %)
586		-Пример программы
	585	+Example program
587	587
588	588	{{code language="assembler"}}
589		-AZ$CSR = 177220; регистр команд и состояния (CSR)
590		-AZ$DR = 177222; регистр данных (DR)
	588	+AZ$CSR = 177220; command and status register (CSR)
	589	+AZ$DR = 177222; data register (DR)
591	591
592	592
593		-; trap 50 - cброс AZ
	592	+; trap 50 - reset AZ
594	594	; результат в R1 =0 ok
595	595	AZreset: MOV #AZ$CSR,R1
596		-1$: CLR (R1); Пошлем команду "Сброс"
597		- TSTB (R1); Проверим готовность контроллера
598		- BPL 1$; Если не готов, сбрасываем еще
599		- ; раз и проверяем снова
600		- 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,
601	601	BMI 0ERR$
602	602	CLR R1
603	603	return
...	...	@@ -606,30 +606,30 @@
606	606	return
607	607
608	608
609		-; trap 54 - чтение энергонезависимой памяти блока 1 EEPROM в буфер с адреса ADREEPROMMEM
610		-; результат R3 - адрес, если R3=0 ошибка
611		-; статус чтения в R1 0 - ok
612		-; 1 - размер не соответствует сохраненному
613		-; 2 - oшибка версии
614		-; 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
615	615	ReadEEPROM: push R2
616		- call AZreset; сбросим
	615	+ call AZreset; reset
617	617	tst R1
618	618	bne 0ERR$
619	619	; теперь читаем
620	620	MOV #AZ$CSR,R1
621		- mov #21,(R1); считать блок 1 энергонезависимой памяти в буфер
622		-0$: TSTB (R1); проверяем результат выполнения
623		- BPL 0$; ждем
624		- mov #22,(R1); отдать на шину считанный блок энергонезависимой памяти из буфера
625		-1$: TSTB (R1); проверяем результат выполнения
626		- BPL 1$; ждем
627		- 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
628	628	mov #ADREEPROMMEM,R3
629		- mov #256.,R2; читаем 256. слов; первое слово - результат чтения
630		-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
631	631	sob R2,2$
632		- mov #ADREEPROMMEM,R3; успешно
	631	+ mov #ADREEPROMMEM,R3; successful
633	633	mov (R3),R1
634	634	br 0END$
635	635	0ERR$: CLR R3
...	...	@@ -637,41 +637,39 @@
637	637	return
638	638	{{/code}}
639	639
640		-очевидно, после считывания памяти необходимо проверить код результата в первом слове - см расшифровку кодов ошибок
641		-\\Примеры возвращаемых данных по командам
642		-\\последовательная подача команды 021 и затем 022 позволит считать 256. слов
643		-из энергонезависимой памяти
644		-**Внимание! **первое слово это будет статус успешности чтения
645		-
	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
646	646
647	647	* 0 - ok
648		-* 1 - размер не соответствует сохраненному
649		-* 2 - oшибка версии
650		-* 3 - oшибка контрольной суммы
	645	+* 1 - size does not match saved
	646	+* 2 - version error
	647	+* 3 - checksum error
651	651
652		-== **023: Принять с шины в буфер данные для последующей записи в буфер** ==
	649	+== 023: Receive data from the bus into the buffer for subsequent writing into the buffer ==
653	653
654		-Код команды 023, данная команда позволяет наполнить буфер энергонезависимой памяти
	651	+Command code 023, this command allows you to fill the non-volatile memory buffer
655	655
656		-== **024: Записать из буфера в блок энергонезависимой памяти** ==
	653	+== 024: Write from buffer to non-volatile memory block ==
657	657
658		-Код команды 024, данная команда вызывает запись блока энергонезависимой памяти из буфера энергонезависимой памяти.
	655	+Command code 024, this command causes a non-volatile memory block to be written from the non-volatile memory buffer.
659	659
660		-Пример программы
	657	+Example program
661	661
662	662	{{code language="assembler"}}
663		-AZ$CSR = 177220; регистр команд и состояния (CSR)
664		-AZ$DR = 177222; регистр данных (DR)
	660	+AZ$CSR = 177220; Command and Status Register (CSR)
	661	+AZ$DR = 177222; Data Register (DR)
665	665
666	666
667		-; trap 50 - cброс AZ
	664	+; trap 50 - reset AZ
668	668	; результат в R1 =0 ok
669	669	AZreset: MOV #AZ$CSR,R1
670		-1$: CLR (R1); Пошлем команду "Сброс"
671		- TSTB (R1); Проверим готовность контроллера
672		- BPL 1$; Если не готов, сбрасываем еще
673		- ; раз и проверяем снова
674		- 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,
675	675	BMI 0ERR$
676	676	CLR R1
677	677	return
...	...	@@ -679,27 +679,27 @@
679	679	COM R1
680	680	return
681	681
682		-; trap 55 - запись энергонезависимой памяти из буфера с адреса ADREEPROMMEM в блок 1 EEPROM
	679	+; trap 55 - write non-volatile memory from the buffer at address ADREEPROMMEM в блок 1 EEPROM
683	683	WriteEEPROM: push R1
684	684	push R2
685	685	push R3
686		- call AZreset; сбросим
	683	+ call AZreset; reset
687	687	tst R1
688	688	bne 0ERR$
689	689
690	690	MOV #AZ$CSR,R1
691		- mov #23,(R1); командуем что будем писать данные в буфер
692		-0$: TSTB (R1); проверяем результат выполнения
693		- BPL 0$; ждем
694		- 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
695	695	mov #ADREEPROMMEM+2,R3
696		- mov #255.,R2; пишем 255. слов; первое слово пропускаем - результат чтения
697		-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
698	698	sob R2,1$
699		- tst -(R1); декрементируем
700		- mov #24,(R1); записать из буфера в блок 1 энергонезависимой памяти
701		-2$: TSTB (R1); проверяем результат выполнения
702		- 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
703	703	br 0END$
704	704	0ERR$: CLR R3
705	705	0END$: pop R3
...	...	@@ -708,23 +708,21 @@
708	708	return
709	709	{{/code}}
710	710
711		-**Обращаю внимание**, при записи, буфер идет сразу с данными, те нет первого слова со статусом.
	708	+**Please note** that when recording, the buffer immediately comes with the data, i.e. there is no first word with the statu
712	712
713	713
714	714
715		-= Блок команд для работы с RTC и NTP =
	712	+= Block of commands for working with RTC and NTP =
716	716
717		-В контроллере 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.
718	718
719	719
720		-== Формат буфера timestamp (доступен по чтению) ==
	717	+== Buffer format timestamp (readable) ==
721	721
722		-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
723	723
724	724	{{info}}
725		-формат буфера даты-времени
726		-offset в восьмеричной системе - те слова
727		-формат буфера даты-времени
	722	+datetime buffer format octal offset - those words datetime buffer format
728	728	\\[0]=rtc_rt11date();
729	729	[2]=rt11 time 50Hz big word;
730	730	[4]=rt11 time 50Hz little word;
...	...	@@ -742,72 +742,72 @@
742	742	{{/info}}
743	743
744	744
745		-== Формат буфера SimpleIN (при записи) ==
	740	+== SimpleIN buffer format (when writing) ==
746	746
747		-формат максимально упрощен, для работы со стороны PDP-11
	742	+the format is simplified as much as possible, for work with PDP-11
748	748
749	749	{{info}}
750		-offset в восьмеричной системе - те слова
	745	+offset in octal - those words
751	751
752		-[0]=year       год, младшие две цифры - те 22 а не 2022(!)
753		-[2]=month;     месяц
754		-[4]=day;       день
755		-[6]=wday;      день недели =0 не установлен, 1- понедельник 2 - вторник итд
756		-[10]=hour;     час
757		-[12]=min;      минута
758		-[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
759	759	{{/info}}
760	760
761	761
762		-== **031:  Получить время из RTC в буфер timestamp** ==
	757	+== 031: Get time from RTC to timestamp buffer ==
763	763
764		-Код команды 031, данная команда использует RTC часы как источник заполнения буфера timestamp
	759	+Command code 031, this command uses RTC clock as a source of filling the timestamp buffer
765	765
766		-Пример программы:
	761	+Example program:
767	767
768	768	{{code language="assembler"}}
769		-; trap 61 - чтение данных часов из автономных часов RTC
770		-; R3 - адрес буфера куда надо считать
771		-; результат в 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
772	772	GetDateFromRTC: push R0
773	773	push R1
774	774	push R2
775		- call AZreset; сбросим
	770	+ call AZreset; reset
776	776	tst R1
777	777	bne G60ERR
778	778	MOV #AZ$CSR,R1
779	779	mov #31,(R1)
780		- br G60; идем туда тк дальше код одинаковый
	775	+ br G60; let's go there because further code is the same
781	781	{{/code}}
782	782
783		-== **032:  Получить время из буфера timestamp** ==
	778	+== 032: Get time from timestamp buffer ==
784	784
785		-Код команды 032, данная команда отдает на шину содержимое буфера timestamp
	780	+Command code 032, this command sends the contents of the timestamp buffer to the bus
786	786
787	787	{{code language="assembler"}}
788		-; работа с часами
789		-; trap 60 - чтение данных часов из TCP/IP стека
790		-; R3 - адрес буфера куда надо считать
791		-; результат в 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
792	792	GetDateFromLAN: push R0
793	793	push R1
794	794	push R2
795		- call AZreset; сбросим
	790	+ call AZreset; reset
796	796	tst R1
797	797	bne G60ERR
798	798	MOV #AZ$CSR,R1
799	799	mov #42,(R1)
800		-G60: TSTB (R1); проверяем результат выполнения
801		- BPL G60; ждем
	795	+G60: TSTB (R1); check execution result
	796	+ BPL G60; wait
802	802	mov #32,(R1)
803		-1$: TSTB (R1); проверяем результат выполнения
	798	+1$: TSTB (R1); check execution result
804	804	BPL 1$; ждем
805		- TST (R1)+; инкрементируем
806		- mov R3,R0; запомним R3 - адрес
807		- mov #10.,R2; читаем 10 слов
808		-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
809	809	sob R2,2$
810		- mov R0,R3; успешно, вернем адрес в R3
	805	+ mov R0,R3; successful, return address to R3
811	811	br 0END$
812	812	G60ERR: CLR R3
813	813	0END$: pop R2
...	...	@@ -816,11 +816,11 @@
816	816	return
817	817	{{/code}}
818	818
819		-Стоит проверить корректность полученного времени:
	814	+It is worth checking the correctness of the received time:
820	820
821	821	{{code language="assembler"}}
822		-; trap 63 - проверка корректности времени
823		-; R3 - адрес буфера, результат в R3, если адрес буфера то OK, =0 ошибка
	817	+; trap 63 - check time correctness
	818	+; R3 - buffer address, result in R3, if buffer address then OK, =0 error
824	824	CheckDateTime: Cmp 6(r3),#2021.
825	825	Blos 1err
826	826	Cmp 6(r3),#2100.
...	...	@@ -830,119 +830,119 @@
830	830	return
831	831	{{/code}}
832	832
833		-== **033:  Запись времени-даты в буфер SimpleIN** ==
	828	+== 033: Write time-date to SimpleIN buffer ==
834	834
835		-Код команды 033, данная команда  принимает с шины данные в буфер SimpleIN
	830	+Command code 033, this command receives data from the bus into the SimpleIN buffer
836	836
837		-Работа данной команды аналогична работе команд [[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.
838	838
839		-== **034:  Установка RTC на основании данных из буфера** ==
	834	+== 034: Set RTC based on buffer data ==
840	840
841		-Код команды 034, данная команда  устанавливает RTC на основании данных в буфере SimpleIN
	836	+Command code 034, this command sets the RTC based on the data in the SimpleIN buffer
842	842
843		-Данная команда выполняется быстро, но для исключения проблем цикл ожидания выполнения рекомендуется.
	838	+This command executes quickly, but to avoid problems, a wait loop is recommended.
844	844
845		-== **035:  Стимуляция запроса времени с NTP сервера, установка на основании ответа** ==
	840	+== 035: Stimulate time request from NTP server, set based on response ==
846	846
847		-Код команды 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.
848	848
849		-Пример программы: отсылка запроса на установку времени с NTP сервера
	844	+Example program: sending a request to set the time from an NTP server
850	850
851	851	{{code language="assembler"}}
852		-; trap 62 - отсылка запроса на установку времени с NTP сервера
	847	+; trap 62 - sending a request to set the time from the NTP server
853	853	GetDateNTPtoNET:push R1
854		- call AZreset; сбросим
	849	+ call AZreset; reset
855	855	tst R1
856	856	bne 0ERR$
857	857	MOV #AZ$CSR,R1
858	858	mov #35,(R1)
859		-0$: TSTB (R1); проверяем результат выполнения
860		- BPL 0$; ждем
	854	+0$: TSTB (R1); check the result of execution
	855	+ BPL 0$; wait
861	861	0ERR$: pop R1
862	862	return
863	863	{{/code}}
864	864
865		-Выполнение команды занимает 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.
866	866
867		-Пример цикла опроса с целью получить время с сети
	862	+An example of a polling cycle to get time from the network
868	868
869	869	{{code language="assembler"}}
870		-; дата-время
	865	+; date-time
871	871	mov #S_DateTime_0,R3; "Lan Date:"
872	872	trap 10
873		- mov #20,R4; количество циклов ожидания
874		-$datry: trap 62; отослали запрос к NTP серверу
875		- mov #110,@#AZ$CSR; включим сеть
876		- trap 47; ожидание
877		- 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
878	878	mov #ADRTMPSTR,R3
879		- trap 60; считали в буфер дату-время
880		- trap 63; проверили дату-время
	874	+ trap 60; read the date-time into the buffer
	875	+ trap 63; checked the date-time
881	881	tst R3
882	882	bne $ok
883	883	$sob: sob R4,$datry
884		- mov #S_DateTime_2,R3; печать ошибки
	879	+ mov #S_DateTime_2,R3; print error
885	885	trap 7
886	886	br $go
887	887
888	888	$ok: mov #ADRTMPSTR,R3
889		- trap 24; печать даты
890		- trap 25; времени
891		-$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
892	892	{{/code}}
893	893
894		-Тут мы явно отсылаем запрос к 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.
895	895
896		-== **036:  Установка RTC на основании часов TCP/IP стека** ==
	891	+== 036: Setting RTC based on TCP/IP stack clock ==
897	897
898		-Код команды 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.
899	899
900		-Пример программы:
	895	+Example program:
901	901
902	902	{{code language="assembler"}}
903		-; trap 64 - установка времени RTC на основании времени стека
904		-; R1 - результат R1=0 - OK
905		-SetDateNETtoRTC:call AZreset; сбросим
	898	+; trap 64 - set RTC time based on stack time
	899	+; R1 - result R1=0 - OK
	900	+SetDateNETtoRTC:call AZreset; reset
906	906	tst R1
907	907	bne 0ERR$
908	908	MOV #AZ$CSR,R1
909	909	mov #36,(R1)
910		-0$: TSTB (R1); проверяем результат выполнения
911		- BPL 0$; ждем
	905	+0$: TSTB (R1); check execution result
	906	+ BPL 0$; wait
912	912	clr R1
913	913	0ERR$: return
914	914	{{/code}}
915	915
916		-== **042:  Получить время из часов TCP/IP стека в буфер timestamp** ==
	911	+== 042: Get time from TCP/IP stack clock into timestamp buffer ==
917	917
918		-Код команды 042,   данная команда использует часы TCP/IP стека как источник заполнения буфера timestamp.
	913	+Command code 042, this command uses the TCP/IP stack clock as a source for filling the timestamp buffer.
919	919
920		-Пример программы:
	915	+Example program:
921	921
922	922	{{code language="assembler"}}
923		-; работа с часами
924		-; trap 60 - чтение данных часов из TCP/IP стека
925		-; R3 - адрес буфера куда надо считать
926		-; результат в 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
927	927	GetDateFromLAN: push R0
928	928	push R1
929	929	push R2
930		- call AZreset; сбросим
	925	+ call AZreset; reset
931	931	tst R1
932	932	bne G60ERR
933	933	MOV #AZ$CSR,R1
934	934	mov #42,(R1)
935		-G60: TSTB (R1); проверяем результат выполнения
936		- BPL G60; ждем
	930	+G60: TSTB (R1); check execution result
	931	+ BPL G60; wait
937	937	mov #32,(R1)
938		-1$: TSTB (R1); проверяем результат выполнения
939		- BPL 1$; ждем
940		- TST (R1)+; инкрементируем
941		- 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
942	942	mov #10.,R2; читаем 10 слов
943		-2$: mov (R1),(R3)+; читаем блок слов в память
	938	+2$: mov (R1),(R3)+; read block of words into memory
944	944	sob R2,2$
945		- mov R0,R3; успешно, вернем адрес в R3
	940	+ mov R0,R3; successful, return address to R3
946	946	br 0END$
947	947	G60ERR: CLR R3
948	948	0END$: pop R2
...	...	@@ -951,52 +951,50 @@
951	951	return
952	952	{{/code}}
953	953
954		-все команды устанавливают бит готовности по завершению.
	949	+All commands set the ready bit upon completion.
955	955
956	956
957		-= **Команды специфические для [[AZБК®>>doc:Контроллеры AZБК® для компьютеров БК-0010 БК-0010\.01 БК-0011М.WebHome]]** =
	952	+= **[[AZБК®>>doc:Контроллеры AZБК® для компьютеров БК-0010 БК-0010\.01 БК-0011М.WebHome]] **specific commands =
958	958
959		-Данные команды предназначены для работы контроллера 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.
960	960
961		-Другие контроллеры AZ® игнорируют эти команды
	956	+Other AZ® controllers ignore these commands.
962	962
963		-== **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 ==
964	964
965		-Код команды 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
966	966
967		-Пример программы
	962	+Example program
968	968
969	969	{{code language="assembler"}}
970		-AZ$CSR = 177220; регистр команд и состояния (CSR)
971		-AZ$DR = 177222; регистр данных (DR)
	965	+AZ$CSR = 177220; command and status register (CSR)
	966	+AZ$DR = 177222; data register (DR)
972	972
973	973
974		-; trap 57 - перезапуск БК полный
975		-AZcouldReboot: call AZreset; сбросим AZ дабы он был готов принимать команды
	969	+; trap 57 - full restart
	970	+AZcouldReboot: call AZreset; reset AZ so it is ready to receive
976	976	mov #037,@#AZ$CSR
977	977	return
978	978	{{/code}}
979	979
980		-== **044: Cохранение скриншота в файл** ==
	975	+== 044: Saving a screenshot to a file ==
981	981
982		-Код команды 044,  данная команда предназначена для снятия образа памяти указанного размера (или определенного автоматически на основании сохраненных параметров)
983		-технически команда может служить как средство отладки ибо способная снимать образ памяти
984		-общее ограничение на снятие образа памяти - 2МБ на один образ
985		-\\в качестве параметров используется служебная страница памяти 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
986	986
987		-Структура заполнения информации о скриншоте
	980	+Structure of filling information about a screenshot
988	988
989	989	{{code language="c"}}
990		-// структура хидера скриншота
	983	+// screenshot header structure
991	991	typedef __packed struct screen_header
992	992	{
993		- unsigned short int tag; // должен быть равен 0240
	986	+ unsigned short int tag; // must be equal to 0240
994	994
995		- unsigned int begin_adress; // начальный адрес в словах - прямая задача в физических адресах
996		- 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
997	997
998		- unsigned short int begin_page; // начальная страница - номер - прямая задача в номерах страниц
999		- 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
1000	1000
1001	1001	unsigned short int R177300; //
1002	1002	unsigned short int R177302; //
...	...	@@ -1014,57 +1014,55 @@
1014	1014	unsigned short int R177332; //
1015	1015	unsigned short int R177334; //
1016	1016	unsigned short int R177336; //
1017		- unsigned short int R177340; // - Регистр управления активацией окно - маски окон
1018		- unsigned short int R177342; // - Регистр управления r/o на окно
1019		- unsigned short int R177344; // - Регистр управления shadow окон - маски окон
1020		- unsigned short int R177346; // - Регистр управления маппером
1021		- unsigned short int R177350; // - регистр копия по записи 177130 в режиме записи управления памятью в SMK
1022		- 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
1023	1023
1024		- unsigned short int R177230; // - регистр управления
1025		- unsigned short int R177232; // - регистр номера страницы начала отображения - верхняя страница (слой 0)
1026		- unsigned short int R177240; // - регистр номера страницы начала отображения - средняя страница (слой 1)
1027		- unsigned short int R177242; // - регистр номера страницы начала отображения - нижняя страница (слой 2)
1028		- unsigned short int R177244; // - регистр вертикального скролинга слой 2
1029		- unsigned short int R177246; // - регистр вертикального скролинга слой 1
1030		- unsigned short int R177250; // - регистр вертикального скролинга слой 0
1031		- unsigned short int R177252; // - регистр гозизонтального скролинга слой 0
1032		- unsigned short int R177254; // - регистр гозизонтального скролинга слой 1
1033		- 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
1034	1034
1035	1035	unsigned short int paldata[338]; //
1036	1036	} screen_header_t;
1037	1037	{{/code}}
1038	1038
1039		-Пример кода для заполнения страницы памяти
	1032	+Example code for filling a memory page
1040	1040
1041	1041	{{code language="assembler"}}
1042	1042	;--------------------------------------------------
1043		-; карта 76й страницы - туда мы готовим данные для команды скринщотов
1044		- SCR_PAGE = 130000 ; 76ую страницу цепляем на место 77й временно - те в окно 130000
1045		- SCR_TAG = SCR_PAGE+0 ; тут вход - 240 - 1 слово
1046		- SCR_ADDR_CONF = SCR_TAG+2 ; сюда команду с адресами - адрес+длина 24 бита - 4 слова
1047		- SCR_PAGE_CONF = SCR_ADDR_CONF+8. ; сюда команду со страницами - начальная страница и количество страниц - 2 слова
1048		- SCR_MEM_CONF = SCR_PAGE_CONF+4. ; cюда конфигурацию памяти из регистров - 22 слова
1049		- SCR_VGA_CONF = SCR_MEM_CONF+44. ; сюда конфигурацию видеоконтроллера - 10 cлов
1050		- 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
1051	1051	;--------------------------------------------------
	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
1052	1052
1053		-
1054		-; trap 41 - подготовка дефолтной информации для работы функционала скриншотов
1055		-PrepSRC: jsr R5, PUSHA ; пакетное сохранение регистров
1056		- mov @#177326,-(SP) ; сохраним страницу 130k которая была до вызова
1057		- mov #76,@#177326 ; цепляем 76ую страницу в окно
1058		-
1059		- mov #100377,R3 ; константа-заполнитель
	1050	+ mov #100377,R3 ; constant-filler
1060	1060	mov #SCR_PAGE,R4
1061	1061	mov #2047.,R2
1062	1062	4$: mov R3,(R4)+
1063	1063	sob R2,4$
1064	1064
1065		- mov #240,@#SCR_TAG ; проставляем тег
	1056	+ mov #240,@#SCR_TAG ; put the tag
1066	1066
1067		- ; чистим участок адресов - дефолтно автоматическое определение адресов
	1058	+ ; clean the address section - default is automatic address detection
1068	1068	clr R3
1069	1069	mov #SCR_ADDR_CONF,R4
1070	1070	mov #10,R2
...	...	@@ -1071,7 +1071,7 @@
1071	1071	2$: mov R3,(R4)+
1072	1072	sob R2,2$
1073	1073
1074		- ;конфигурация памяти - дефолтная
	1065	+ ; memory configuration - default
1075	1075	mov #SCR_MEM_CONF,R4
1076	1076	mov #30,(R4)+ ;177300
1077	1077	mov #31,(R4)+ ;177302
...	...	@@ -1090,29 +1090,29 @@
1090	1090	mov #110,(R4)+ ;177334
1091	1091	mov #100,(R4)+ ;177336
1092	1092
1093		- mov #170000,(R4)+ ;177340 - Регистр управления активацией окно - маски окон
1094		- mov R3,(R4)+ ;177342 - Регистр управления r/o на окно
1095		- mov #7777,(R4)+ ;177344 - Регистр управления shadow окон - маски окон
1096		- mov #40404,(R4)+ ;177346 - Регистр управления маппером
1097		- mov R3,(R4)+ ;177350 - регистр копия по записи 177130 в режиме записи управления памятью в SMK
1098		- 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
1099	1099
1100		- ;конфигурация видеоконтроллера - дефолтная
	1091	+ ;Video controller configuration - default
1101	1101	; 177230-177256
1102	1102	mov #SCR_VGA_CONF,R4
1103	1103
1104		- mov #12201,(R4)+ ;177230 - регистр управления
1105		- mov #4,(R4)+ ;177232 - регистр номера страницы начала отображения - верхняя страница (слой 0)
1106		- mov R3,(R4)+ ;177240 - регистр номера страницы начала отображения - средняя страница (слой 1) "под спрайты"
1107		- mov R3,(R4)+ ;177242 - регистр номера страницы начала отображения - нижняя страница (слой 2) "под фон"
1108		- mov R3,(R4)+ ;177244 - регистр вертикального скролинга слой 2
1109		- mov R3,(R4)+ ;177246 - регистр вертикального скролинга слой 1
1110		- mov R3,(R4)+ ;177250 - регистр вертикального скролинга слой 0
1111		- mov R3,(R4)+ ;177252 - регистр гозизонтального скролинга слой 0
1112		- mov R3,(R4)+ ;177254 - регистр гозизонтального скролинга слой 1
1113		- 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
1114	1114
1115		- ; закачиваем палитру - берем дефолтную из этой ПЗУшки
	1106	+ ; download the palette - take the default one from this ROM
1116	1116	mov #SCR_PAL,R4
1117	1117	mov #PalData,R2
1118	1118	mov #338.,R3
...	...	@@ -1119,233 +1119,233 @@
1119	1119	1$: mov (R2)+,(R4)+
1120	1120	sob R3,1$
1121	1121
1122		- mov (SP)+,@#177326; вернем страницу с которой был вызов
	1113	+ mov (SP)+,@#177326; return the page from which the call was made
1123	1123	return
1124	1124	{{/code}}
1125	1125
1126		-Вариантов указания участков памяти три
	1117	+There are three options for specifying memory areas.
1127	1127
1128		-1. указать адрес и длину 24х битные - cм формат, если их нет - система смотрит дальше
1129		-1. указать номер страницы и количество страницы, если их нет
1130		-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.
1131	1131
1132		-Cкриншот сохраняется в формате
1133		-- страница 76 - ее первый килобайт
1134		-- сам образ памяти (если режим слоеный - то все три слоя)
	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)
1135	1135
1136	1136
1137		-Перед вызовом команды можно загрузить имя файла для сохранения скриншота [в cmosmem буфер], однако при его отсутствии (в буфере не будет имени - строки заканчивающейся 0) система сформирует свое имя, на основании следующего правила:
1138		-дефолтный путь для сохранения скриншотов
	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
1139	1139	0:/SCREENS/
1140		-формат имени - DDHHMISS.SCR
1141		-где DD - две цифры дня месяца, HH - час, MI - минута, SS-секунда
1142		-\\Если в процессе выполнения команды возникнет ошибка - вместо имени будет "ERROR *"
1143		-к примеру
	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
1144	1144	"ERROR f_open 6"
1145	1145
1146	1146
1147		-Пример программы
	1137	+Example program
1148	1148
1149	1149	{{code language="assembler"}}
1150		-; обновим информацию в хидере скриншота
	1140	+; update the information in the screenshot header
1151	1151	;--------------------------------------------------
1152		-; карта 76й страницы - туда мы готовим данные для команды скринщотов
1153		- SPAGE = 170000 ; 76ую страницу цепляем на место 77й временно - те в окно 130000
1154		- STAG = SPAGE+0 ; тут вход - 240 - 1 слово
1155		- SADDRC = STAG+2 ; сюда команду с адресами - адрес+длина 24 бита - 4 слова
1156		- SPAGEC = SADDRC+8. ; сюда команду со страницами - начальная страница и количество страниц - 2 слова
1157		- SMEMC = SPAGEC+4. ; cюда конфигурацию памяти из регистров - 22 слова
1158		- SVGAC = SMEMC+44. ; сюда конфигурацию видеоконтроллера - 10 cлов
1159		- 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
1160	1160	;--------------------------------------------------
	1151	+ mov @#177326,R5 ; save page 130k which was before the call
	1152	+ mov #76,@#177336 ; hook the 76th page into the window
1161	1161
1162		- mov @#177326,R5 ; сохраним страницу 130k которая была до вызова
1163		- mov #76,@#177336 ; цепляем 76ую страницу в окно
1164		-
1165		- ;конфигурация видеоконтроллера
	1154	+ ;video controller configuration
1166	1166	; 177230-177256
1167	1167	mov #SVGAC,R4
1168	1168
1169		- mov @#177230,(R4)+;177230 - регистр управления
1170		- mov @#177232,(R4)+;177232 - регистр - верхняя страница (слой 0)
1171		- mov @#177240,(R4)+;177240 - регистр - средняя страница (слой 1)
1172		- mov @#177242,(R4)+;177242 - регистр - нижняя страница (слой 2)
1173		- mov @#177244,(R4)+;177244 - регистр вертикального скролинга слой 2
1174		- mov @#177246,(R4)+;177246 - регистр вертикального скролинга слой 1
1175		- mov @#177250,(R4)+;177250 - регистр вертикального скролинга слой 0
1176		- mov @#177252,(R4)+;177252 - регистр гозизонтального скролинга слой 0
1177		- mov @#177254,(R4)+;177254 - регистр гозизонтального скролинга слой 1
1178		- 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
1179	1179
1180		- mov R5,@#177336; вернем страницу с которой был вызов
	1169	+ mov R5,@#177336; return the page from which the call was made
1181	1181
1182	1182
1183	1183	;-------------------------
1184		- MOV #AZ$CSR,R3 ; Готовим CSR контроллера
1185		- MOV #AZ$DR,R4 ; Готовим DR контроллера
1186		-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
1187	1187	TSTB (R3)
1188	1188	BPL 20$
1189	1189
1190		- ; очистим блок памяти для имени - дабы система сделала дефолтное имя файла
1191		- mov #23,(R3) ; командуем что будем писать данные в буфер
1192		-128$: TSTB (R3) ; проверяем результат выполнения
1193		- 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
1194	1194	clr R1
1195	1195
1196	1196	mov #256.,R2 ;
1197		-129$: mov R1,(R4) ; отдаем в контроллер
	1186	+129$: mov R1,(R4) ; give to the controller
1198	1198	sob R2,129$
1199	1199
1200	1200
1201		- MOV #044,(R3) ; команда скриншот
	1190	+ MOV #044,(R3) ; screenshot command
1202	1202	22$: TSTB (R3) ;
1203	1203	BPL 22$ ;
1204	1204
1205		- ; получим имя скриншота
1206		- mov #22,(R3) ; отдать на шину считанный блок памяти из буфера
1207		-121$: tstb (R3) ; проверяем результат выполнения
1208		- 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
1209	1209
1210	1210	mov #BUF,R1
1211		- mov #256.,R2 ; читаем 256. слов; первое слово - результат чтения
1212		-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
1213	1213	sob R2,122$
1214	1214
1215	1215	.PRINT #RESOK
1216	1216	.Print #BUF
1217	1217
1218		- mov #110,@#AZ$CSR; включаем сеть по-умолчанию сеть должна быть постоянно включена
	1207	+ mov #110,@#AZ$CSR; enable the network by default, the network should be constantly enabled
1219	1219	.Exit
1220	1220	{{/code}}
1221	1221
1222		-Для распаковки скриншота можно использовать вот эту утилиту
	1211	+To unpack a screenshot, you can use this utility - [[https:~~/~~/master.pdp-11.ru/screen_unpack/>>https://master.pdp-11.ru/screen_unpack/]]
1223	1223
1224	1224
1225	1225
1226		-= **Команды для работы со стеком TCP/IP** =
	1215	+= Commands for working with the TCP/IP stack =
1227	1227
1228		-следующие команды работают с буфером информации TCP/IP cтека.
	1217	+The following commands operate on the TCP/IP stack information buffer.
1229	1229
1230		-== **040: Получить ip адрес и прочие настройки стека TCP/IP в буфер** ==
	1219	+== 040: Get IP address and other TCP/IP stack settings to buffer ==
1231	1231
1232		-Код команды 040,  данная команда заполняет буфер информацией с TCP/IP cтека текущей (фактической) информацией.
	1221	+Command code 040, this command fills the buffer with information from the TCP/IP stack with current (actual) information.
1233	1233
1234		-== **041: Чтение буфера ip адреса** ==
	1223	+== 041: Reading ip address buffer ==
1235	1235
1236		-Код команды 041,  данная команда передает буфер на шину
	1225	+Command code 041, this command transfers the buffer to the bus
1237	1237
1238		-эта пара команд позволяет получить текущую информацию со стека
	1227	+This pair of commands allows you to get current information from the stack
1239	1239
1240		-* IP адрес
1241		-* MASK маску
1242		-* GW гейтвей
1243		-* NTP адрес NTP-сервера
1244		-* DNS1 адрес основного DNS
1245		-* 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
1246	1246
1247		-соответственно это 12 слов
	1236	+accordingly it is 12 words
1248	1248
1249		-Пример программы:
	1238	+Example program:
1250	1250
1251	1251	{{code language="assembler"}}
1252		-; trap 52 - чтение блока IP адресов в блок памяти IPADDDBLOCK (8. ячеек)
1253		-; результат в R3 =0 error, иначе адрес куда считано (IPADDDBLOCK)
1254		-GetIPaddrs: push R1
1255		- push R2
1256		- call AZreset; сбросим
1257		- tst R1
1258		- bne 0ERR$
1259		- MOV #AZ$CSR,R1
1260		- mov #40,(R1)
1261		-0$: TSTB (R1); прочитать адреса в свою память
1262		- BPL 0$; ждем
1263		- mov #41,(R1)
1264		-1$: TSTB (R1); подготовить буфер
1265		- BPL 1$; ждем
1266		- TST (R1)+; инкрементируем
1267		- mov #IPADDDBLOCK,R3
1268		- mov #12.,R2
1269		-2$: mov (R1),(R3)+; читаем блок слов в память
1270		- sob R2,2$
1271		- mov #IPADDDBLOCK,R3; успешно
1272		- br 0END$
1273		-0ERR$: CLR R3
1274		-0END$: pop R2
1275		- pop R1
1276		- 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	+
1277	1277	{{/code}}
1278	1278
1279		-Пример данных
	1269	+Example return data:
1280	1280
1281	1281	{{info}}
1282		-Примеры данных - возвращаемые слова в восьмеричном формате
1283		-124300 116400 - IP адрес 192.168.0.157
1284		-177777 000377 - MASK маску 255.255.255.0
1285		-124300 000400 - GW гейтвей 192.168.0.1
1286		-124300 000400 - NTP адрес NTP-сервера 192.168.0.1
1287		-124300 050000 - DNS1 адрес основного DNS 192.168.0.90
1288		-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
1289	1289	{{/info}}
1290	1290
1291		-== **043: чтение MAC-адреса в ip буфер** ==
	1281	+== 043: Read MAC address into ip buffer ==
1292	1292
1293		-Код команды 043, данная команда читает текущий фактический MAC адрес в буфер IP адресов
1294		-те сначала 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
1295	1295
1296		-Пример программы:
	1285	+Example program:
1297	1297
1298	1298	{{code language="assembler"}}
1299		-; trap 72 - чтение MAC адреса в блок памяти IPADDDBLOCK (12. ячеек)
1300		-; результат в R3 =0 error, иначе адрес куда считано (IPADDDBLOCK)
1301		-GetMACaddrs: push R1
1302		- push R2
1303		- call AZreset ; сбросим
1304		- tst R1
1305		- bne 0ERR$
1306		- MOV #AZ$CSR,R1
1307		- mov #43,(R1)
1308		-0$: TSTB (R1) ; прочитать адреса в свою память
1309		- BPL 0$ ; ждем
1310		- mov #41,(R1)
1311		-1$: TSTB (R1) ; подготовить буфер
1312		- BPL 1$ ; ждем
1313		- TST (R1)+ ; инкрементируем
1314		- mov #IPADDDBLOCK,R3
1315		- mov #12.,R2
1316		-2$: mov (R1),(R3)+ ; читаем блок слов в память
1317		- sob R2,2$
1318		- mov #IPADDDBLOCK,R3; успешно
1319		- br 0END$
1320		-0ERR$: CLR R3
1321		-0END$: pop R2
1322		- pop R1
1323		- 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	+
1324	1324	{{/code}}
1325	1325
1326	1326
1327	1327
1328		-= **Команды для работы с MicroSD картой на файловом уровне** =
	1318	+= Commands for working with a MicroSD card at the file level =
1329	1329
1330	1330
1331		-Данные команды предназначены для работы с 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.
1332	1332
1333		-Эти команды используют буфер 256. слов который задействован в интерфейсе работы с энергонезависимой памятью (см выше команды 022 023)
1334		-\\Ограничения - длина полного пути к файлу  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)
1335	1335
1336		-== **050: Установить имя файла который будем читать** ==
	1325	+Limitations - the length of the full path to the file is 256 bytes
1337	1337
1338		-Код команды 050,  данная команда устанавливает имя файла который будем читать, при этом производится открытие файла на чтение, а также получение его свойств.
	1327	+== 050: Set the name of the file we will read ==
1339	1339
1340		-== **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.
1341	1341
1342		-Код команды 051,  данная команда передает на МПИ размер файла или ошибку его чтения. Размер файла 31бит, старший бит является признаком ошибки. Соответственно максимальный размер файлов с которыми можно работать через этот интерфейс ограничен 2^31 байт (2GB).
	1331	+== 051: Get file size for reading (or its status) on BUS ==
1343	1343
1344		-формирование ошибки выглядит так:
1345		-sizeanyfile=1<<31 + FFres; ~/~/ если установлен старший бит 32х битного слова - то в младшей части код ошибки
1346		-\\FFres = ошибка FatFS
1347		-
	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).
1348	1348
	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	+
1349	1349	{{code language="c"}}
1350	1350	typedef enum {
1351	1351	FR_OK = 0, /* (0) Succeeded */
...	...	@@ -1373,317 +1373,309 @@
1373	1373
1374	1374	[[http:~~/~~/elm-chan.org/fsw/ff/doc/open.html>>url:http://elm-chan.org/fsw/ff/doc/open.html]]
1375	1375
1376		-== **052: Читать блок установленного файла в буфер** ==
	1367	+== 052: Read a block of a set file into a buffer ==
1377	1377
1378		-Код команды 052,  данная команда осуществляет чтение файла в буфер энергонезависимой памяти.
	1369	+Command code 052, this command reads a file into a non-volatile memory buffer.
1379	1379
1380		-В итоге схема чтения файла выглядит вот так
1381		-**023** - заливаем имя файла в буфер
1382		-**050** - устанавливаем файл на чтение
1383		-**051 **- читаем длину файла или ошибку открытия файла
1384		-если ошибка - повторяем сначала 023 050 051
1385		-если все ok - приступаем к чтению файла
1386		-**052** - читает блок файла в буфер
1387		-**022 **- забираем данные из буфера
1388		-пары 052 022 повторяем нужное количество раз дабы считать весь файл
1389		-как файл будет прочтен - последняя 052 команда закроет его автоматически.
1390		-
	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.
1391	1391
1392		-Пример программы
	1382	+Example program:
1393	1393
1394	1394	{{code language="assembler"}}
	1385	+ call AZRST; reset
1395	1395
1396		- 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
1397	1397
1398		-; заливаем в буфер имя файла
1399		-7$: mov #23,(R1); командуем что будем писать данные в буфер
1400		-5$: TSTB (R1); проверяем результат выполнения
1401		- BPL 5$ ; ждем
1402		- TST (R1)+; инкрементируем
1403		- mov #FILNM,R3
1404		-1$: mov (R3),(R1); отдаем в контроллер
1405		- tst (R3)+
1406		- bne 1$
1407		- 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
1408	1408
	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
1409	1409
1410		- ; устанавливаем файл на чтение
1411		- mov #50,(R1); устанавливаем файл на чтение
1412		-2$: TSTB (R1); проверяем результат выполнения
1413		- 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
1414	1414
	1421	+; read the file
	1422	+ mov R1,R4; R1 holds the file length
	1423	+ MOV #AZ$CSR,R1
	1424	+ mov #BUFFL,R5
1415	1415
1416		- ; читаем длину файда
1417		- mov #51,(R1); устанавливаем файл на чтение
1418		-3$: TSTB (R1); проверяем результат выполнения
1419		- BPL 3$ ; ждем
1420		- TST (R1)+; инкрементируем
1421		- mov #FILSZ,R3
1422		- mov (R1),(R3)+; читаем с контроллера
1423		- 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
1424	1424
1425		- ; выведем длину файла на экран
1426		- clr R0
1427		- mov #FILSZ+2,R3
1428		- mov (R3),R1
1429		- call DNOZ
1430		- mov -(R3),R1
1431		- call DNOZ
1432		- .print #STMS2
	1430	+47$: tst R4
	1431	+ beq 45$ ; nothing left to read - exit
1433	1433
1434		- ; читаем файл
1435		- mov R1,R4; в R1 осталась длина файла
1436		- MOV #AZ$CSR,R1
1437		- 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
1438	1438
1439		- bit #1,R4; если нечетное число байт
1440		- beq 47$
1441		- inc R4; добавим еще 1 байт тк читаем словами
	1440	+ cmp R4,#512.; compare with buffer size in bytes
	1441	+ Blos 44$ ; less than buffer size left
1442	1442
1443		-47$: tst R4
1444		- 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$
1445	1445
	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$
1446	1446
1447		- mov #52,(R1); читаем блок в буфер
1448		-4$: TSTB (R1); проверяем результат выполнения
1449		- BPL 4$ ; ждем
1450		- mov #22,(R1); будем читать буфер
1451		-51$: TSTB (R1); проверяем результат выполнения
1452		- BPL 51$ ; ждем
	1459	+45$: clr (R5); set end of file marker
1453	1453
1454		- cmp R4,#512.; сравниваем c размером буфера в байтах
1455		- Blos 44$ ; осталось меньше чем буфер
	1461	+; file read - display on screen
	1462	+ .print #STMS4
	1463	+ .print #BUFFL
	1464	+ .print #STMS5
1456	1456
	1466	+ mov #110,@#AZ$CSR; enable network
	1467	+ .Exit
1457	1457
1458		- .print #STMS1
1459		- mov #256.,R2
1460		- TST (R1)+; переходим на регистр данных
1461		-46$: mov (R1),(R5)+; читаем в буфер
1462		- sob R2,46$
1463		- sub #512.,R4; вычитаем
1464		- TST -(R1); переходим на регистр команд
1465		- br 47$
1466		-
1467		-44$: .print #STMS3
1468		- mov R4,R2
1469		- asr R2 ; /2 тк читаем словами
1470		- TST (R1)+; переходим на регистр данных
1471		-43$: mov (R1),(R5)+; читаем в буфер
1472		- sob R2,43$
1473		-
1474		-
1475		-45$: clr (R5); проставим конец файла
1476		- ; файл считан - выводим на экран
1477		- .print #STMS4
1478		- .print #BUFFL
1479		- .print #STMS5
1480		-
1481		-
1482		- mov #110,@#AZ$CSR; включаем сеть
1483		- .Exit
1484	1484	{{/code}}
1485	1485
1486	1486
1487	1487
1488		-== **053:** установить имя файла который будем писать ==
	1473	+== 053: set the name of the file that we will write ==
1489	1489
1490		-Код команды 053,  данная команда открывает файл на запись, получает параметры открытия (или ошибки).
	1475	+Command code 053, this command opens a file for writing, receives opening parameters (or errors).
1491	1491
1492		-== **054:** установка длины файла ==
	1477	+== 054: Set file length ==
1493	1493
1494		-Код команды 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.
1495	1495
1496		-== **055:** записать в файл данные из буфера ==
	1481	+== 055: write data from buffer to file ==
1497	1497
1498		-Код команды 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.
1499	1499
1500		-Схема подачи команд при записи вот такая
1501		-**023** - заливаем имя файла в буфер
1502		-**053** - устанавливаем файл на чтение
1503		-**051 **- статус открытия/создания файла
1504		-если ошибка - повторяем сначала 023 053 051
1505		-если все ok - идем дальше
1506		-**054** - установка длины файла, те надо сразу объявить какая у нас будет длина файла
1507		-**023** - заливаем блок данных в буфер
1508		-**055** - пишем из буфера в файл
1509		-пары 023 055 повторяем нужное количество раз дабы записать весь файл
1510		-как файл будет записан - последняя 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
1511	1511
1512	1512
1513		-Пример программы:
	1498	+Example program:
1514	1514
1515	1515	{{code language="assembler"}}
1516		-; заливаем в буфер имя файла
1517		- MOV #AZ$CSR,R1
1518		-17$: mov #23,(R1); командуем что будем писать данные в буфер
1519		-15$: TSTB (R1) ; проверяем результат выполнения
1520		- BPL 15$ ; ждем
1521		- TST (R1)+ ; переходим на регистр данных
1522		- mov #FILNM2,R3
1523		-11$: mov (R3),(R1); отдаем в контроллер
1524		- tst (R3)+
1525		- bne 11$
1526		- 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
1527	1527
1528		- ; устанавливаем файл на запись
1529		- mov #53,(R1); устанавливаем файл на запись
1530		-12$: TSTB (R1) ; проверяем результат выполнения
1531		- 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
1532	1532
	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
1533	1533
1534		- ; читаем статус создания файла
1535		- mov #51,(R1)
1536		-13$: TSTB (R1) ; проверяем результат выполнения
1537		- BPL 13$ ; ждем
1538		- TST (R1)+ ; переходим на регистр данных
1539		- mov #STATS,R3
1540		- mov (R1),(R3)+; читаем с контроллера
1541		- 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
1542	1542
1543		- ; тут надо проверить - если файл создан то оба слова нулевые
1544		- mov #STATS,R3
1545		- TST (R3)+
1546		- BNE 66$
1547		- TST (R3)
1548		- BEQ 60$
1549		-66$: .print #ERRMS1 ; печать ошибки
1550		- .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
1551	1551
1552		-60$: MOV #AZ$CSR,R1
1553		- mov #54,(R1); установим длину файла который будем писать
1554		-23$: TSTB (R1) ; проверяем результат выполнения
1555		- BPL 23$ ; ждем
1556		- TST (R1)+ ; переходим на регистр данных
1557		- mov #FILSZ,R3
1558		- mov (R3)+,(R1); пишем в контроллер
1559		- mov (R3),(R1); пишем в контроллер
	1545	+ tst -(R1) ; move to command register
1560	1560
1561		- tst -(R1) ; переходим на регистр команд
	1547	+; write file
	1548	+ mov @#FILSZ,R4; file length
	1549	+ MOV #AZ$CSR,R1
	1550	+ mov #BUFFL,R5; file buffer
1562	1562
	1552	+ bit #1,R4 ; if an odd number of bytes
	1553	+ beq 147$
	1554	+ inc R4 ; add 1 more byte since reading words
1563	1563
	1556	+147$: tst R4 ; check length
	1557	+ beq 145$ ; nothing left to write - exit
1564	1564
1565		- ; пишем файл
1566		- mov @#FILSZ,R4; длина файла
1567		- MOV #AZ$CSR,R1
1568		- mov #BUFFL,R5; буфер файла
	1559	+ mov #23,(R1); write to buffer
	1560	+151$: TSTB (R1) ; check execution result
	1561	+ BPL 151$ ; wait
1569	1569
1570		- bit #1,R4 ; если нечетное число байт
1571		- beq 147$
1572		- inc R4 ; добавим еще 1 байт тк читаем словами
	1563	+ cmp R4,#512.; compare with buffer size in bytes
	1564	+ Blos 144$ ; less than buffer size left
1573	1573
1574		-147$: tst R4 ; проверим длину
1575		- 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
1576	1576
1577		- mov #23,(R1); будем писать в буфер
1578		-151$: TSTB (R1) ; проверяем результат выполнения
1579		- 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
1580	1580
1581		- cmp R4,#512.; сравниваем c размером буфера в байтах
1582		- 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$
1583	1583
1584		- .print #STMS6 ; заливка полного блока
1585		- mov #256.,R2
1586		- TST (R1)+ ; переходим на регистр данных
1587		-146$: mov (R5)+,(R1); пишем в буфер контроллера
1588		- sob R2,146$
1589		- sub #512.,R4; вычитаем
1590		- 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
1591	1591
1592		- mov #55,(R1); запись буфера в файл
1593		-104$: TSTB (R1) ; проверяем результат выполнения
1594		- BPL 104$ ; ждем
1595		- br 147$ ; в начало
	1591	+145$: .print #STMSE ; end
	1592	+ mov #110,@#AZ$CSR; enable network
	1593	+ .Exit ; exit
1596	1596
1597		-144$: .print #STMS7 ; заливка последнего блока
1598		- TST (R1)+ ; переходим на регистр данных
1599		- mov R4,R2
1600		- asr R2 ; /2 тк пишем словами
1601		-143$: mov (R5)+,(R1); пишем в буфер контроллера
1602		- sob R2,143$
1603		-
1604		- TST -(R1) ; переходим на регистр команд
1605		- mov #55,(R1); запись пследнего буфера в файл
1606		-105$: TSTB (R1) ; проверяем результат выполнения
1607		- BPL 105$ ; ждем
1608		-
1609		-145$: .print #STMSE ; конец
1610		- mov #110,@#AZ$CSR; включаем сеть
1611		- .Exit ; выходим
1612	1612	{{/code}}
1613	1613
1614		-**[[пример полностью в виде утилиты 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]]**
1615	1615
1616	1616
1617		-== **056: Получить данные по размеру карты в буфер sizecard** ==
	1600	+== 056: Get data on the size of the map into the sizecard buffer ==
1618	1618
1619		-Код команды 056,  данная команда читает параметры MicroSD карты в буфер sizecard
	1602	+Command code 056, this command reads the parameters of the MicroSD card into the sizecard buffer
1620	1620
1621		-== **057: Чтение буфера sizecard** ==
	1604	+== 057: Reading sizecard buffer ==
1622	1622
1623		-Код команды 057,  данная команда отдает буфер sizecard (2 слова)
	1606	+Command code 057, this command returns the sizecard buffer (2 words)
1624	1624
1625		-буфер sizecard содержит 2 слова 16bit
1626		-первое слово - общий объем карты доступный для FAT в МБ
1627		-второе слово - свободный объем на карте в МБ
	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
1628	1628
1629		-Пример программы:
	1612	+Example program:
1630	1630
1631	1631	{{code language="assembler"}}
1632		-; trap 51 - получение объема SD карты всего/свободно в мегабайтах
1633		-; результат в R1 - всего; R2 - свободно
1634		-GetSizeSD: call AZreset; сбросим
1635		- tst R1
1636		- bne 0ERR$
1637		- MOV #AZ$CSR,R1
1638		- mov #56,(R1)
1639		-1$: TSTB (R1); подготовить буфер
1640		- BPL 1$; ждем
1641		- mov #57,(R1)
1642		-2$: TSTB (R1); подготовить буфер
1643		- BPL 2$; ждем
1644		- mov @#AZ$DR ,R1; всего мегабайт
1645		- mov @#AZ$DR ,R2; свободно мегабайт
1646		- return
1647		- clr R1
1648		- clr R2
1649		- 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	+
1650	1650	{{/code}}
1651	1651
1652		-Пример данных
1653		-035521 - всего на карточке мегабайт - 15185.
1654		-035417 - свободно мегабайт - 15119.
1655		-
	1636	+Example data
	1637	+035521 - total megabytes on the card - 15185.
	1638	+035417 - free megabytes - 15119.
1656	1656
1657		-= **Блок команд API Hall of Fame** =
	1640	+= Hall of Fame API Command Block =
1658	1658
1659		-Данный блок команд предназначен для взаимодействия с сервером [[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]]
1660	1660
1661	1661	== **025: Инициализация Hall of Fame (HOF)** ==
1662	1662
1663		-Код команды 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.
1664	1664
1665		-Пример программы
	1648	+Example program:
1666	1666
1667	1667	{{code language="assembler"}}
1668		-AZ$CSR = 177220 ; регистр команд и состояния (CSR)
1669		-AZ$DR = 177222 ; регистр данных (DR)
	1651	+AZ$CSR = 177220 ; command and status register (CSR)
	1652	+AZ$DR = 177222 ; data register (DR)
1670	1670
1671		-; буфера
1672		-SNDBUF: .BLKW 256. ; буфер передачи
1673		-RCVBUF: .BLKW 256. ; буфер приема ответа
	1654	+; buffers
	1655	+SNDBUF: .BLKW 256. ; send buffer
	1656	+RCVBUF: .BLKW 256. ; receive buffer
1674	1674	SIDMEM: .BLKB 34. ; SID
1675		-SIDCST: .ASCII \{"SID":"\ ; заголовок SID-а
	1658	+SIDCST: .ASCII \{"SID":"\ ; SID header
1676	1676	.even
1677	1677
1678		-HOFINI: ; инициализация HOF
1679		- ;результатом является такой JSON
1680		- ;{"SID":"хеш сессии","RESULT":"OK"}
1681		- ;или ошибка
1682		- ;{"RESULT":"ERROR","DESCRIPTION":"SERVER_ERROR"}
1683		- ;{"RESULT":"ERROR","DESCRIPTION":"CONNECTION_ERROR"}
1684		- ; результат помещается в SNDBUF
1685		- ; в R5 фиксация успешности - =1 есть SID, =0 нет SID-а
1686		-
	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	+
1687	1687	mov R5, -(SP)
1688	1688	mov R4, -(SP)
1689	1689	mov R3, -(SP)
...	...	@@ -1691,29 +1691,29 @@
1691	1691	mov R1, -(SP)
1692	1692	mov R0, -(SP)
1693	1693
1694		- mov #3,R5 ; количество попыток
	1677	+ mov #3,R5 ; number of attempts
1695	1695
1696	1696	220$: mov #AZ$CSR,R1
1697		- clr (R1) ; Пошлем команду "Сброс"
1698		-221$: tstb (R1) ; Проверим готовность контроллера
1699		- bpl 221$ ; Если не готов ждем
	1680	+ clr (R1) ; Send "Reset" command
	1681	+221$: tstb (R1) ; Check controller readiness
	1682	+ bpl 221$ ; If not ready, wait
1700	1700
1701		- mov #25,(R1) ; инициализация - команда 025
1702		-20$: tstb (R1) ; проверяем результат выполнения
1703		- bpl 20$ ; ждем
	1684	+ mov #25,(R1) ; initialization - command 025
	1685	+20$: tstb (R1) ; check execution result
	1686	+ bpl 20$ ; wait
1704	1704
1705		- ; получим результат
1706		- mov #22,(R1) ; отдать на шину считанный блок памяти из буфера
1707		-21$: tstb (R1) ; проверяем результат выполнения
1708		- bpl 21$ ; ждем
1709		- 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
1710	1710	mov #SNDBUF,R3
1711		- mov #256.,R2 ; читаем 256. слов; первое слово - результат чтения
1712		-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
1713	1713	sob R2,22$
1714	1714
1715	1715
1716		- ; надо понять - есть ли SID
	1699	+ ; Determine if SID exists
1717	1717	mov #4,R0
1718	1718	mov #SNDBUF,R1
1719	1719	mov #SIDCST,R2
...	...	@@ -1722,11 +1722,11 @@
1722	1722	sob R0,23$
1723	1723	clr R5
1724	1724	inc R5
1725		- br 26$ ; успешно
	1708	+ br 26$ ; success
1726	1726
1727		-24$: ; SID не найден!
	1710	+24$: ; SID not found!
1728	1728	sob R5,220$
1729		- clr R5 ; ошибка - нет SID-а
	1712	+ clr R5 ; error - no SID
1730	1730
1731	1731	26$: mov (SP)+, R0
1732	1732	mov (SP)+, R1
...	...	@@ -1735,69 +1735,71 @@
1735	1735	mov (SP)+, R4
1736	1736	mov (SP)+, R5
1737	1737	return
	1721	+
1738	1738	{{/code}}
1739	1739
1740		-== **026: обмен с Hall of Fame (HOF)** ==
	1724	+== 026: Exchange with Hall of Fame (HOF) ==
1741	1741
1742		-Код команды 026,  данная команда осуществляет непосредственный обмен с Hall of Fame
	1726	+Command code 026, this command makes a direct exchange with Hall of Fame
1743	1743
1744		-Пример программы
	1728	+Example program:
1745	1745
1746	1746	{{code language="assembler"}}
1747		- ;4. авторизация пользователя
1748		- ;технически это отправка JSON
1749		- ;{"SID":"хеш сессии","CMD":"AUTH_USER","NIKNAME":"никнейм пользователя","PASSWORD":"пароль пользователя"}
1750		- ;ответ тоже JSON
1751		- ;{"SID":"хеш сессии","RESULT":"OK","UID":"хеш пользователя"}
1752		- ;или
1753		- ;{"SID":"хеш сессии","RESULT":"ERROR","DESCRIPTION":"USER_NOT_FOUND_OR_WRONG_PASSWORD"}
1754		- ;{"SID":"хеш сессии","RESULT":"ERROR","DESCRIPTION":"SERVER_ERROR"}
1755		- ;{"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"}
1756	1756
1757		- ; загоняем команду CMD04
1758		- mov #CMD04,R1
1759		- mov #ADRMEM,R2
1760		- add #42.,R2 ; cдвигаем указатель на длину блока с SID
1761		-33$: movb (R1)+,(R2)+
1762		- 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$
1763	1763
1764		- .Print #ADRMEM
	1748	+ .Print #ADRMEM
1765	1765
1766		- .Print #HOF05
1767		- ; отсылаем команду и ждем ответа
1768		- ; закачиваем в буфер
1769		- MOV #AZ$CSR,R1
1770		-331$: TSTB (R1) ; Проверим готовность контроллера
1771		- BPL 331$ ; Если не готов ждем
1772		- mov #23,(R1) ; командуем что будем писать данные в буфер
1773		-34$: TSTB (R1) ; проверяем результат выполнения
1774		- BPL 34$ ; ждем
1775		- TST (R1)+ ; инкрементируем
1776		- mov #ADRMEM,R3
1777		- mov #256.,R2 ;
1778		-35$: mov (R3)+,(R1) ; отдаем в контроллер
1779		- sob R2,35$
1780		- 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
1781	1781
1782		- ; обмен - команда 026
1783		- MOV #AZ$CSR,R1
1784		-361$: TSTB (R1) ; Проверим готовность контроллера
1785		- BPL 361$ ; Если не готов ждем
1786		- mov #26,(R1)
1787		-36$: TSTB (R1) ; проверяем результат выполнения
1788		- 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
1789	1789
1790		- ; получим результат
1791		-371$: TSTB (R1) ; Проверим готовность контроллера
1792		- BPL 371$ ; Если не готов ждем
1793		- mov #22,(R1) ; отдать на шину буфер
1794		-37$: TSTB (R1) ; проверяем результат выполнения
1795		- BPL 37$ ; ждем
1796		- TST (R1)+ ; инкрементируем
1797		- mov #ADRMEM,R3
1798		- mov #256.,R2 ; читаем 256. слов; первое слово - результат чтения
1799		-38$: mov (R1),(R3)+ ; читаем блок слов в память
1800		- 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	+
1801	1801	{{/code}}
1802	1802
1803	1803