Skip to Content
Last modified by Max on 2025/03/02 15:18
From version 2.49
edited by Max
on 2025/02/25 15:17
Change comment: (Autosaved)
To version 2.1479
edited by Max
on 2025/03/02 14:53
Change comment: (Autosaved)

Summary

Details

Page properties
Content
... ... @@ -862,82 +862,82 @@
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х битные - cм формат, если их нет - система смотрит дальше
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