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

Summary

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

Details

Page properties

Content

...	...	@@ -1033,29 +1033,31 @@
1033	1033
1034	1034	{{code language="assembler"}}
1035	1035	;--------------------------------------------------
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
	1036	+; карта 76й страницы - туда мы готовим данные для команды скринщотов
	1037	+ SCR_PAGE = 130000 ; 76ую страницу цепляем на место 77й временно - те в окно 130000
	1038	+ SCR_TAG = SCR_PAGE+0 ; тут вход - 240 - 1 слово
	1039	+ SCR_ADDR_CONF = SCR_TAG+2 ; сюда команду с адресами - адрес+длина 24 бита - 4 слова
	1040	+ SCR_PAGE_CONF = SCR_ADDR_CONF+8. ; сюда команду со страницами - начальная страница и количество страниц - 2 слова
	1041	+ SCR_MEM_CONF = SCR_PAGE_CONF+4. ; cюда конфигурацию памяти из регистров - 22 слова
	1042	+ SCR_VGA_CONF = SCR_MEM_CONF+44. ; сюда конфигурацию видеоконтроллера - 10 cлов
	1043	+ SCR_PAL = SCR_VGA_CONF+20. ; сюда 338. значений(слов) палитры 338 слов
1044	1044	;--------------------------------------------------
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
1049	1049
1050		- mov #100377,R3 ; constant-filler
	1046	+
	1047	+; trap 41 - подготовка дефолтной информации для работы функционала скриншотов
	1048	+PrepSRC: jsr R5, PUSHA ; пакетное сохранение регистров
	1049	+ mov @#177326,-(SP) ; сохраним страницу 130k которая была до вызова
	1050	+ mov #76,@#177326 ; цепляем 76ую страницу в окно
	1051	+
	1052	+ mov #100377,R3 ; константа-заполнитель
1051	1051	mov #SCR_PAGE,R4
1052	1052	mov #2047.,R2
1053	1053	4$: mov R3,(R4)+
1054	1054	sob R2,4$
1055	1055
1056		- mov #240,@#SCR_TAG ; put the tag
	1058	+ mov #240,@#SCR_TAG ; проставляем тег
1057	1057
1058		- ; clean the address section - default is automatic address detection
	1060	+ ; чистим участок адресов - дефолтно автоматическое определение адресов
1059	1059	clr R3
1060	1060	mov #SCR_ADDR_CONF,R4
1061	1061	mov #10,R2
...	...	@@ -1062,7 +1062,7 @@
1062	1062	2$: mov R3,(R4)+
1063	1063	sob R2,2$
1064	1064
1065		- ; memory configuration - default
	1067	+ ;конфигурация памяти - дефолтная
1066	1066	mov #SCR_MEM_CONF,R4
1067	1067	mov #30,(R4)+ ;177300
1068	1068	mov #31,(R4)+ ;177302
...	...	@@ -1081,29 +1081,29 @@
1081	1081	mov #110,(R4)+ ;177334
1082	1082	mov #100,(R4)+ ;177336
1083	1083
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
	1086	+ mov #170000,(R4)+ ;177340 - Регистр управления активацией окно - маски окон
	1087	+ mov R3,(R4)+ ;177342 - Регистр управления r/o на окно
	1088	+ mov #7777,(R4)+ ;177344 - Регистр управления shadow окон - маски окон
	1089	+ mov #40404,(R4)+ ;177346 - Регистр управления маппером
	1090	+ mov R3,(R4)+ ;177350 - регистр копия по записи 177130 в режиме записи управления памятью в SMK
	1091	+ mov #16000,(R4)+ ;177352 - регистр копия по записи 177716 в режиме записи управления памятью в БК11М
1090	1090
1091		- ;Video controller configuration - default
	1093	+ ;конфигурация видеоконтроллера - дефолтная
1092	1092	; 177230-177256
1093	1093	mov #SCR_VGA_CONF,R4
1094	1094
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
	1097	+ mov #12201,(R4)+ ;177230 - регистр управления
	1098	+ mov #4,(R4)+ ;177232 - регистр номера страницы начала отображения - верхняя страница (слой 0)
	1099	+ mov R3,(R4)+ ;177240 - регистр номера страницы начала отображения - средняя страница (слой 1) "под спрайты"
	1100	+ mov R3,(R4)+ ;177242 - регистр номера страницы начала отображения - нижняя страница (слой 2) "под фон"
	1101	+ mov R3,(R4)+ ;177244 - регистр вертикального скролинга слой 2
	1102	+ mov R3,(R4)+ ;177246 - регистр вертикального скролинга слой 1
	1103	+ mov R3,(R4)+ ;177250 - регистр вертикального скролинга слой 0
	1104	+ mov R3,(R4)+ ;177252 - регистр гозизонтального скролинга слой 0
	1105	+ mov R3,(R4)+ ;177254 - регистр гозизонтального скролинга слой 1
	1106	+ mov R3,(R4)+ ;177256 - регистр гозизонтального скролинга слой 2
1105	1105
1106		- ; download the palette - take the default one from this ROM
	1108	+ ; закачиваем палитру - берем дефолтную из этой ПЗУшки
1107	1107	mov #SCR_PAL,R4
1108	1108	mov #PalData,R2
1109	1109	mov #338.,R3
...	...	@@ -1110,233 +1110,233 @@
1110	1110	1$: mov (R2)+,(R4)+
1111	1111	sob R3,1$
1112	1112
1113		- mov (SP)+,@#177326; return the page from which the call was made
	1115	+ mov (SP)+,@#177326; вернем страницу с которой был вызов
1114	1114	return
1115	1115	{{/code}}
1116	1116
1117		-There are three options for specifying memory areas.
	1119	+Вариантов указания участков памяти три
1118	1118
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.
	1121	+1. указать адрес и длину 24х битные - cм формат, если их нет - система смотрит дальше
	1122	+1. указать номер страницы и количество страницы, если их нет
	1123	+1. система смотрит дальше - те делает скриншот на основании данных о регистрах 177230 и т.д..
1122	1122
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)
	1125	+Cкриншот сохраняется в формате
	1126	+- страница 76 - ее первый килобайт
	1127	+- сам образ памяти (если режим слоеный - то все три слоя)
1126	1126
1127	1127
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
	1130	+Перед вызовом команды можно загрузить имя файла для сохранения скриншота [в cmosmem буфер], однако при его отсутствии (в буфере не будет имени - строки заканчивающейся 0) система сформирует свое имя, на основании следующего правила:
	1131	+дефолтный путь для сохранения скриншотов
1129	1129	0:/SCREENS/
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
	1133	+формат имени - DDHHMISS.SCR
	1134	+где DD - две цифры дня месяца, HH - час, MI - минута, SS-секунда
	1135	+\\Если в процессе выполнения команды возникнет ошибка - вместо имени будет "ERROR *"
	1136	+к примеру
1134	1134	"ERROR f_open 6"
1135	1135
1136	1136
1137		-Example program
	1140	+Пример программы
1138	1138
1139	1139	{{code language="assembler"}}
1140		-; update the information in the screenshot header
	1143	+; обновим информацию в хидере скриншота
1141	1141	;--------------------------------------------------
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
	1145	+; карта 76й страницы - туда мы готовим данные для команды скринщотов
	1146	+ SPAGE = 170000 ; 76ую страницу цепляем на место 77й временно - те в окно 130000
	1147	+ STAG = SPAGE+0 ; тут вход - 240 - 1 слово
	1148	+ SADDRC = STAG+2 ; сюда команду с адресами - адрес+длина 24 бита - 4 слова
	1149	+ SPAGEC = SADDRC+8. ; сюда команду со страницами - начальная страница и количество страниц - 2 слова
	1150	+ SMEMC = SPAGEC+4. ; cюда конфигурацию памяти из регистров - 22 слова
	1151	+ SVGAC = SMEMC+44. ; сюда конфигурацию видеоконтроллера - 10 cлов
	1152	+ SPAL = SVGAC+20. ; сюда 338. значений(слов) палитры 338 слов
1150	1150	;--------------------------------------------------
1151		- mov @#177326,R5 ; save page 130k which was before the call
1152		- mov #76,@#177336 ; hook the 76th page into the window
1153	1153
1154		- ;video controller configuration
	1155	+ mov @#177326,R5 ; сохраним страницу 130k которая была до вызова
	1156	+ mov #76,@#177336 ; цепляем 76ую страницу в окно
	1157	+
	1158	+ ;конфигурация видеоконтроллера
1155	1155	; 177230-177256
1156	1156	mov #SVGAC,R4
1157	1157
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
	1162	+ mov @#177230,(R4)+;177230 - регистр управления
	1163	+ mov @#177232,(R4)+;177232 - регистр - верхняя страница (слой 0)
	1164	+ mov @#177240,(R4)+;177240 - регистр - средняя страница (слой 1)
	1165	+ mov @#177242,(R4)+;177242 - регистр - нижняя страница (слой 2)
	1166	+ mov @#177244,(R4)+;177244 - регистр вертикального скролинга слой 2
	1167	+ mov @#177246,(R4)+;177246 - регистр вертикального скролинга слой 1
	1168	+ mov @#177250,(R4)+;177250 - регистр вертикального скролинга слой 0
	1169	+ mov @#177252,(R4)+;177252 - регистр гозизонтального скролинга слой 0
	1170	+ mov @#177254,(R4)+;177254 - регистр гозизонтального скролинга слой 1
	1171	+ mov @#177256,(R4)+;177256 - регистр гозизонтального скролинга слой 2
1168	1168
1169		- mov R5,@#177336; return the page from which the call was made
	1173	+ mov R5,@#177336; вернем страницу с которой был вызов
1170	1170
1171	1171
1172	1172	;-------------------------
1173		- MOV #AZ$CSR,R3 ; Preparing controller CSR
1174		- MOV #AZ$DR,R4 ; Preparing controller DR
1175		-20$: CLR (R3) ; Reset the controller
	1177	+ MOV #AZ$CSR,R3 ; Готовим CSR контроллера
	1178	+ MOV #AZ$DR,R4 ; Готовим DR контроллера
	1179	+20$: CLR (R3) ; Сбросим контроллер
1176	1176	TSTB (R3)
1177	1177	BPL 20$
1178	1178
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
	1183	+ ; очистим блок памяти для имени - дабы система сделала дефолтное имя файла
	1184	+ mov #23,(R3) ; командуем что будем писать данные в буфер
	1185	+128$: TSTB (R3) ; проверяем результат выполнения
	1186	+ BPL 128$ ; ждем
1183	1183	clr R1
1184	1184
1185	1185	mov #256.,R2 ;
1186		-129$: mov R1,(R4) ; give to the controller
	1190	+129$: mov R1,(R4) ; отдаем в контроллер
1187	1187	sob R2,129$
1188	1188
1189	1189
1190		- MOV #044,(R3) ; screenshot command
	1194	+ MOV #044,(R3) ; команда скриншот
1191	1191	22$: TSTB (R3) ;
1192	1192	BPL 22$ ;
1193	1193
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
	1198	+ ; получим имя скриншота
	1199	+ mov #22,(R3) ; отдать на шину считанный блок памяти из буфера
	1200	+121$: tstb (R3) ; проверяем результат выполнения
	1201	+ bpl 121$ ; ждем
1198	1198
1199	1199	mov #BUF,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
	1204	+ mov #256.,R2 ; читаем 256. слов; первое слово - результат чтения
	1205	+122$: mov (R4),(R1)+ ; читаем блок слов в память
1202	1202	sob R2,122$
1203	1203
1204	1204	.PRINT #RESOK
1205	1205	.Print #BUF
1206	1206
1207		- mov #110,@#AZ$CSR; enable the network by default, the network should be constantly enabled
	1211	+ mov #110,@#AZ$CSR; включаем сеть по-умолчанию сеть должна быть постоянно включена
1208	1208	.Exit
1209	1209	{{/code}}
1210	1210
1211		-To unpack a screenshot, you can use this utility - [[https:~~/~~/master.pdp-11.ru/screen_unpack/>>https://master.pdp-11.ru/screen_unpack/]]
	1215	+Для распаковки скриншота можно использовать вот эту утилиту
1212	1212
1213	1213
1214	1214
1215		-= Commands for working with the TCP/IP stack =
	1219	+= **Команды для работы со стеком TCP/IP** =
1216	1216
1217		-The following commands operate on the TCP/IP stack information buffer.
	1221	+следующие команды работают с буфером информации TCP/IP cтека.
1218	1218
1219		-== 040: Get IP address and other TCP/IP stack settings to buffer ==
	1223	+== **040: Получить ip адрес и прочие настройки стека TCP/IP в буфер** ==
1220	1220
1221		-Command code 040, this command fills the buffer with information from the TCP/IP stack with current (actual) information.
	1225	+Код команды 040,  данная команда заполняет буфер информацией с TCP/IP cтека текущей (фактической) информацией.
1222	1222
1223		-== 041: Reading ip address buffer ==
	1227	+== **041: Чтение буфера ip адреса** ==
1224	1224
1225		-Command code 041, this command transfers the buffer to the bus
	1229	+Код команды 041,  данная команда передает буфер на шину
1226	1226
1227		-This pair of commands allows you to get current information from the stack
	1231	+эта пара команд позволяет получить текущую информацию со стека
1228	1228
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
	1233	+* IP адрес
	1234	+* MASK маску
	1235	+* GW гейтвей
	1236	+* NTP адрес NTP-сервера
	1237	+* DNS1 адрес основного DNS
	1238	+* DNS2 адрес резервного DNS
1235	1235
1236		-accordingly it is 12 words
	1240	+соответственно это 12 слов
1237	1237
1238		-Example program:
	1242	+Пример программы:
1239	1239
1240	1240	{{code language="assembler"}}
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		-
	1245	+; trap 52 - чтение блока IP адресов в блок памяти IPADDDBLOCK (8. ячеек)
	1246	+; результат в R3 =0 error, иначе адрес куда считано (IPADDDBLOCK)
	1247	+GetIPaddrs: push R1
	1248	+ push R2
	1249	+ call AZreset; сбросим
	1250	+ tst R1
	1251	+ bne 0ERR$
	1252	+ MOV #AZ$CSR,R1
	1253	+ mov #40,(R1)
	1254	+0$: TSTB (R1); прочитать адреса в свою память
	1255	+ BPL 0$; ждем
	1256	+ mov #41,(R1)
	1257	+1$: TSTB (R1); подготовить буфер
	1258	+ BPL 1$; ждем
	1259	+ TST (R1)+; инкрементируем
	1260	+ mov #IPADDDBLOCK,R3
	1261	+ mov #12.,R2
	1262	+2$: mov (R1),(R3)+; читаем блок слов в память
	1263	+ sob R2,2$
	1264	+ mov #IPADDDBLOCK,R3; успешно
	1265	+ br 0END$
	1266	+0ERR$: CLR R3
	1267	+0END$: pop R2
	1268	+ pop R1
	1269	+ return
1267	1267	{{/code}}
1268	1268
1269		-Example return data:
	1272	+Пример данных
1270	1270
1271	1271	{{info}}
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
	1275	+Примеры данных - возвращаемые слова в восьмеричном формате
	1276	+124300 116400 - IP адрес 192.168.0.157
	1277	+177777 000377 - MASK маску 255.255.255.0
	1278	+124300 000400 - GW гейтвей 192.168.0.1
	1279	+124300 000400 - NTP адрес NTP-сервера 192.168.0.1
	1280	+124300 050000 - DNS1 адрес основного DNS 192.168.0.90
	1281	+124300 055000 - DNS2 адрес резервного DNS 192.168.0.80
1279	1279	{{/info}}
1280	1280
1281		-== 043: Read MAC address into ip buffer ==
	1284	+== **043: чтение MAC-адреса в ip буфер** ==
1282	1282
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
	1286	+Код команды 043, данная команда читает текущий фактический MAC адрес в буфер IP адресов
	1287	+те сначала 043, а затем 041 команды
1284	1284
1285		-Example program:
	1289	+Пример программы:
1286	1286
1287	1287	{{code language="assembler"}}
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		-
	1292	+; trap 72 - чтение MAC адреса в блок памяти IPADDDBLOCK (12. ячеек)
	1293	+; результат в R3 =0 error, иначе адрес куда считано (IPADDDBLOCK)
	1294	+GetMACaddrs: push R1
	1295	+ push R2
	1296	+ call AZreset ; сбросим
	1297	+ tst R1
	1298	+ bne 0ERR$
	1299	+ MOV #AZ$CSR,R1
	1300	+ mov #43,(R1)
	1301	+0$: TSTB (R1) ; прочитать адреса в свою память
	1302	+ BPL 0$ ; ждем
	1303	+ mov #41,(R1)
	1304	+1$: TSTB (R1) ; подготовить буфер
	1305	+ BPL 1$ ; ждем
	1306	+ TST (R1)+ ; инкрементируем
	1307	+ mov #IPADDDBLOCK,R3
	1308	+ mov #12.,R2
	1309	+2$: mov (R1),(R3)+ ; читаем блок слов в память
	1310	+ sob R2,2$
	1311	+ mov #IPADDDBLOCK,R3; успешно
	1312	+ br 0END$
	1313	+0ERR$: CLR R3
	1314	+0END$: pop R2
	1315	+ pop R1
	1316	+ retur
1314	1314	{{/code}}
1315	1315
1316	1316
1317	1317
1318		-= Commands for working with a MicroSD card at the file level =
	1321	+= **Команды для работы с MicroSD картой на файловом уровне** =
1319	1319
1320	1320
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.
	1324	+Данные команды предназначены для работы с MicroSD картой на уровне файловой системы и позволяет читать/писать файлы без монтирования файлов как образов дисков.
1322	1322
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)
	1326	+Эти команды используют буфер 256. слов который задействован в интерфейсе работы с энергонезависимой памятью (см выше команды 022 023)
	1327	+\\Ограничения - длина полного пути к файлу  256 байт
1324	1324
1325		-Limitations - the length of the full path to the file is 256 bytes
	1329	+== **050: Установить имя файла который будем читать** ==
1326	1326
1327		-== 050: Set the name of the file we will read ==
	1331	+Код команды 050,  данная команда устанавливает имя файла который будем читать, при этом производится открытие файла на чтение, а также получение его свойств.
1328	1328
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.
	1333	+== **051: Получить размер файла на чтение (или его статус) на МПИ** ==
1330	1330
1331		-== 051: Get file size for reading (or its status) on BUS ==
	1335	+Код команды 051,  данная команда передает на МПИ размер файла или ошибку его чтения. Размер файла 31бит, старший бит является признаком ошибки. Соответственно максимальный размер файлов с которыми можно работать через этот интерфейс ограничен 2^31 байт (2GB).
1332	1332
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).
	1337	+формирование ошибки выглядит так:
	1338	+sizeanyfile=1<<31 + FFres; ~/~/ если установлен старший бит 32х битного слова - то в младшей части код ошибки
	1339	+\\FFres = ошибка FatFS
	1340	+
1334	1334
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		-
1340	1340	{{code language="c"}}
1341	1341	typedef enum {
1342	1342	FR_OK = 0, /* (0) Succeeded */
...	...	@@ -1364,280 +1364,288 @@
1364	1364
1365	1365	[[http:~~/~~/elm-chan.org/fsw/ff/doc/open.html>>url:http://elm-chan.org/fsw/ff/doc/open.html]]
1366	1366
1367		-== 052: Read a block of a set file into a buffer ==
	1369	+== **052: Читать блок установленного файла в буфер** ==
1368	1368
1369		-Command code 052, this command reads a file into a non-volatile memory buffer.
	1371	+Код команды 052,  данная команда осуществляет чтение файла в буфер энергонезависимой памяти.
1370	1370
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.
	1373	+В итоге схема чтения файла выглядит вот так
	1374	+**023** - заливаем имя файла в буфер
	1375	+**050** - устанавливаем файл на чтение
	1376	+**051 **- читаем длину файла или ошибку открытия файла
	1377	+если ошибка - повторяем сначала 023 050 051
	1378	+если все ok - приступаем к чтению файла
	1379	+**052** - читает блок файла в буфер
	1380	+**022 **- забираем данные из буфера
	1381	+пары 052 022 повторяем нужное количество раз дабы считать весь файл
	1382	+как файл будет прочтен - последняя 052 команда закроет его автоматически.
	1383	+
1381	1381
1382		-Example program:
	1385	+Пример программы
1383	1383
1384	1384	{{code language="assembler"}}
1385		- call AZRST; reset
1386	1386
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
	1389	+ call AZRST; сбросим
1397	1397
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
	1391	+; заливаем в буфер имя файла
	1392	+7$: mov #23,(R1); командуем что будем писать данные в буфер
	1393	+5$: TSTB (R1); проверяем результат выполнения
	1394	+ BPL 5$ ; ждем
	1395	+ TST (R1)+; инкрементируем
	1396	+ mov #FILNM,R3
	1397	+1$: mov (R3),(R1); отдаем в контроллер
	1398	+ tst (R3)+
	1399	+ bne 1$
	1400	+ tst -(R1); декрементируем
1402	1402
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
1411	1411
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
	1403	+ ; устанавливаем файл на чтение
	1404	+ mov #50,(R1); устанавливаем файл на чтение
	1405	+2$: TSTB (R1); проверяем результат выполнения
	1406	+ BPL 2$ ; ждем
1420	1420
1421		-; read the file
1422		- mov R1,R4; R1 holds the file length
1423		- MOV #AZ$CSR,R1
1424		- mov #BUFFL,R5
1425	1425
1426		- bit #1,R4; if an odd number of bytes
1427		- beq 47$
1428		- inc R4; add 1 more byte as we read words
	1409	+ ; читаем длину файда
	1410	+ mov #51,(R1); устанавливаем файл на чтение
	1411	+3$: TSTB (R1); проверяем результат выполнения
	1412	+ BPL 3$ ; ждем
	1413	+ TST (R1)+; инкрементируем
	1414	+ mov #FILSZ,R3
	1415	+ mov (R1),(R3)+; читаем с контроллера
	1416	+ mov (R1),(R3); читаем с контроллера
1429	1429
1430		-47$: tst R4
1431		- beq 45$ ; nothing left to read - exit
	1418	+ ; выведем длину файла на экран
	1419	+ clr R0
	1420	+ mov #FILSZ+2,R3
	1421	+ mov (R3),R1
	1422	+ call DNOZ
	1423	+ mov -(R3),R1
	1424	+ call DNOZ
	1425	+ .print #STMS2
1432	1432
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
	1427	+ ; читаем файл
	1428	+ mov R1,R4; в R1 осталась длина файла
	1429	+ MOV #AZ$CSR,R1
	1430	+ mov #BUFFL,R5
1439	1439
1440		- cmp R4,#512.; compare with buffer size in bytes
1441		- Blos 44$ ; less than buffer size left
	1432	+ bit #1,R4; если нечетное число байт
	1433	+ beq 47$
	1434	+ inc R4; добавим еще 1 байт тк читаем словами
1442	1442
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$
	1436	+47$: tst R4
	1437	+ beq 45$ ; уже нечего читать - выходим
1451	1451
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$
1458	1458
1459		-45$: clr (R5); set end of file marker
	1440	+ mov #52,(R1); читаем блок в буфер
	1441	+4$: TSTB (R1); проверяем результат выполнения
	1442	+ BPL 4$ ; ждем
	1443	+ mov #22,(R1); будем читать буфер
	1444	+51$: TSTB (R1); проверяем результат выполнения
	1445	+ BPL 51$ ; ждем
1460	1460
1461		-; file read - display on screen
1462		- .print #STMS4
1463		- .print #BUFFL
1464		- .print #STMS5
	1447	+ cmp R4,#512.; сравниваем c размером буфера в байтах
	1448	+ Blos 44$ ; осталось меньше чем буфер
1465	1465
1466		- mov #110,@#AZ$CSR; enable network
1467		- .Exit
1468	1468
	1451	+ .print #STMS1
	1452	+ mov #256.,R2
	1453	+ TST (R1)+; переходим на регистр данных
	1454	+46$: mov (R1),(R5)+; читаем в буфер
	1455	+ sob R2,46$
	1456	+ sub #512.,R4; вычитаем
	1457	+ TST -(R1); переходим на регистр команд
	1458	+ br 47$
	1459	+
	1460	+44$: .print #STMS3
	1461	+ mov R4,R2
	1462	+ asr R2 ; /2 тк читаем словами
	1463	+ TST (R1)+; переходим на регистр данных
	1464	+43$: mov (R1),(R5)+; читаем в буфер
	1465	+ sob R2,43$
	1466	+
	1467	+
	1468	+45$: clr (R5); проставим конец файла
	1469	+ ; файл считан - выводим на экран
	1470	+ .print #STMS4
	1471	+ .print #BUFFL
	1472	+ .print #STMS5
	1473	+
	1474	+
	1475	+ mov #110,@#AZ$CSR; включаем сеть
	1476	+ .Exit
1469	1469	{{/code}}
1470	1470
1471	1471
1472	1472
1473		-== 053: set the name of the file that we will write ==
	1481	+== **053:** установить имя файла который будем писать ==
1474	1474
1475		-Command code 053, this command opens a file for writing, receives opening parameters (or errors).
	1483	+Код команды 053,  данная команда открывает файл на запись, получает параметры открытия (или ошибки).
1476	1476
1477		-== 054: Set file length ==
	1485	+== **054:** установка длины файла ==
1478	1478
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.
	1487	+Код команды 054,  данная команда устанавливает ожидаемую длину файла, это нужно для корректного формирования файла на файловом уровне MicroSD карты, а также для организации передачи данных.
1480	1480
1481		-== 055: write data from buffer to file ==
	1489	+== **055:** записать в файл данные из буфера ==
1482	1482
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.
	1491	+Код команды 055,  данная команда записывает в открытый файл на запись данные из буфера энергонезависимой памяти. Последняя команда 055 автоматически закроет файл по достижению заявленной длины файла.
1484	1484
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
	1493	+Схема подачи команд при записи вот такая
	1494	+**023** - заливаем имя файла в буфер
	1495	+**053** - устанавливаем файл на чтение
	1496	+**051 **- статус открытия/создания файла
	1497	+если ошибка - повторяем сначала 023 053 051
	1498	+если все ok - идем дальше
	1499	+**054** - установка длины файла, те надо сразу объявить какая у нас будет длина файла
	1500	+**023** - заливаем блок данных в буфер
	1501	+**055** - пишем из буфера в файл
	1502	+пары 023 055 повторяем нужное количество раз дабы записать весь файл
	1503	+как файл будет записан - последняя 055 команда закроет его автоматически
1496	1496
1497	1497
1498		-Example program:
	1506	+Пример программы:
1499	1499
1500	1500	{{code language="assembler"}}
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
	1509	+; заливаем в буфер имя файла
	1510	+ MOV #AZ$CSR,R1
	1511	+17$: mov #23,(R1); командуем что будем писать данные в буфер
	1512	+15$: TSTB (R1) ; проверяем результат выполнения
	1513	+ BPL 15$ ; ждем
	1514	+ TST (R1)+ ; переходим на регистр данных
	1515	+ mov #FILNM2,R3
	1516	+11$: mov (R3),(R1); отдаем в контроллер
	1517	+ tst (R3)+
	1518	+ bne 11$
	1519	+ tst -(R1) ; переходим на регистр команд
1512	1512
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
	1521	+ ; устанавливаем файл на запись
	1522	+ mov #53,(R1); устанавливаем файл на запись
	1523	+12$: TSTB (R1) ; проверяем результат выполнения
	1524	+ BPL 12$ ; ждем
1517	1517
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
1526	1526
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
	1527	+ ; читаем статус создания файла
	1528	+ mov #51,(R1)
	1529	+13$: TSTB (R1) ; проверяем результат выполнения
	1530	+ BPL 13$ ; ждем
	1531	+ TST (R1)+ ; переходим на регистр данных
	1532	+ mov #STATS,R3
	1533	+ mov (R1),(R3)+; читаем с контроллера
	1534	+ mov (R1),(R3); читаем с контроллера
1535	1535
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
	1536	+ ; тут надо проверить - если файл создан то оба слова нулевые
	1537	+ mov #STATS,R3
	1538	+ TST (R3)+
	1539	+ BNE 66$
	1540	+ TST (R3)
	1541	+ BEQ 60$
	1542	+66$: .print #ERRMS1 ; печать ошибки
	1543	+ .exit
1544	1544
1545		- tst -(R1) ; move to command register
	1545	+60$: MOV #AZ$CSR,R1
	1546	+ mov #54,(R1); установим длину файла который будем писать
	1547	+23$: TSTB (R1) ; проверяем результат выполнения
	1548	+ BPL 23$ ; ждем
	1549	+ TST (R1)+ ; переходим на регистр данных
	1550	+ mov #FILSZ,R3
	1551	+ mov (R3)+,(R1); пишем в контроллер
	1552	+ mov (R3),(R1); пишем в контроллер
1546	1546
1547		-; write file
1548		- mov @#FILSZ,R4; file length
1549		- MOV #AZ$CSR,R1
1550		- mov #BUFFL,R5; file buffer
	1554	+ tst -(R1) ; переходим на регистр команд
1551	1551
1552		- bit #1,R4 ; if an odd number of bytes
1553		- beq 147$
1554		- inc R4 ; add 1 more byte since reading words
1555	1555
1556		-147$: tst R4 ; check length
1557		- beq 145$ ; nothing left to write - exit
1558	1558
1559		- mov #23,(R1); write to buffer
1560		-151$: TSTB (R1) ; check execution result
1561		- BPL 151$ ; wait
	1558	+ ; пишем файл
	1559	+ mov @#FILSZ,R4; длина файла
	1560	+ MOV #AZ$CSR,R1
	1561	+ mov #BUFFL,R5; буфер файла
1562	1562
1563		- cmp R4,#512.; compare with buffer size in bytes
1564		- Blos 144$ ; less than buffer size left
	1563	+ bit #1,R4 ; если нечетное число байт
	1564	+ beq 147$
	1565	+ inc R4 ; добавим еще 1 байт тк читаем словами
1565	1565
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
	1567	+147$: tst R4 ; проверим длину
	1568	+ beq 145$ ; уже нечего писать - выходим
1573	1573
1574		- mov #55,(R1); write buffer to file
1575		-104$: TSTB (R1) ; check execution result
1576		- BPL 104$ ; wait
1577		- br 147$ ; loop back
	1570	+ mov #23,(R1); будем писать в буфер
	1571	+151$: TSTB (R1) ; проверяем результат выполнения
	1572	+ BPL 151$ ; ждем
1578	1578
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$
	1574	+ cmp R4,#512.; сравниваем c размером буфера в байтах
	1575	+ Blos 144$ ; осталось меньше чем буфер
1585	1585
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
	1577	+ .print #STMS6 ; заливка полного блока
	1578	+ mov #256.,R2
	1579	+ TST (R1)+ ; переходим на регистр данных
	1580	+146$: mov (R5)+,(R1); пишем в буфер контроллера
	1581	+ sob R2,146$
	1582	+ sub #512.,R4; вычитаем
	1583	+ TST -(R1) ; переходим на регистр команд
1590	1590
1591		-145$: .print #STMSE ; end
1592		- mov #110,@#AZ$CSR; enable network
1593		- .Exit ; exit
	1585	+ mov #55,(R1); запись буфера в файл
	1586	+104$: TSTB (R1) ; проверяем результат выполнения
	1587	+ BPL 104$ ; ждем
	1588	+ br 147$ ; в начало
1594	1594
	1590	+144$: .print #STMS7 ; заливка последнего блока
	1591	+ TST (R1)+ ; переходим на регистр данных
	1592	+ mov R4,R2
	1593	+ asr R2 ; /2 тк пишем словами
	1594	+143$: mov (R5)+,(R1); пишем в буфер контроллера
	1595	+ sob R2,143$
	1596	+
	1597	+ TST -(R1) ; переходим на регистр команд
	1598	+ mov #55,(R1); запись пследнего буфера в файл
	1599	+105$: TSTB (R1) ; проверяем результат выполнения
	1600	+ BPL 105$ ; ждем
	1601	+
	1602	+145$: .print #STMSE ; конец
	1603	+ mov #110,@#AZ$CSR; включаем сеть
	1604	+ .Exit ; выходим
1595	1595	{{/code}}
1596	1596
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]]**
	1607	+**[[пример полностью в виде утилиты RT11 выложен вот тут>>url:https://forum.maxiol.com/index.php?s=&showtopic=5605&view=findpost&p=57055]]**
1598	1598
1599	1599
1600		-== 056: Get data on the size of the map into the sizecard buffer ==
	1610	+== **056: Получить данные по размеру карты в буфер sizecard** ==
1601	1601
1602		-Command code 056, this command reads the parameters of the MicroSD card into the sizecard buffer
	1612	+Код команды 056,  данная команда читает параметры MicroSD карты в буфер sizecard
1603	1603
1604		-== 057: Reading sizecard buffer ==
	1614	+== **057: Чтение буфера sizecard** ==
1605	1605
1606		-Command code 057, this command returns the sizecard buffer (2 words)
	1616	+Код команды 057,  данная команда отдает буфер sizecard (2 слова)
1607	1607
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
	1618	+буфер sizecard содержит 2 слова 16bit
	1619	+первое слово - общий объем карты доступный для FAT в МБ
	1620	+второе слово - свободный объем на карте в МБ
1611	1611
1612		-Example program:
	1622	+Пример программы:
1613	1613
1614	1614	{{code language="assembler"}}
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		-
	1625	+; trap 51 - получение объема SD карты всего/свободно в мегабайтах
	1626	+; результат в R1 - всего; R2 - свободно
	1627	+GetSizeSD: call AZreset; сбросим
	1628	+ tst R1
	1629	+ bne 0ERR$
	1630	+ MOV #AZ$CSR,R1
	1631	+ mov #56,(R1)
	1632	+1$: TSTB (R1); подготовить буфер
	1633	+ BPL 1$; ждем
	1634	+ mov #57,(R1)
	1635	+2$: TSTB (R1); подготовить буфер
	1636	+ BPL 2$; ждем
	1637	+ mov @#AZ$DR ,R1; всего мегабайт
	1638	+ mov @#AZ$DR ,R2; свободно мегабайт
	1639	+ return
	1640	+ clr R1
	1641	+ clr R2
	1642	+ return
1634	1634	{{/code}}
1635	1635
1636		-Example data
1637		-035521 - total megabytes on the card - 15185.
1638		-035417 - free megabytes - 15119.
	1645	+Пример данных
	1646	+035521 - всего на карточке мегабайт - 15185.
	1647	+035417 - свободно мегабайт - 15119.
	1648	+
1639	1639
1640		-= Hall of Fame API Command Block =
	1650	+= **Блок команд API Hall of Fame** =
1641	1641
1642	1642	Данный блок команд предназначен для взаимодействия с сервером [[Hall of Fame>>https://forum.maxiol.com/index.php?showtopic=5642]]
1643	1643
...	...	@@ -1645,7 +1645,7 @@
1645	1645
1646	1646	Код команды 025,  данная команда устанавливает соединение с сервером Hall of Fame, инициализирует шифрованный тоннель и подготавливает API к работе.
1647	1647
1648		-Example program:
	1658	+Пример программы
1649	1649
1650	1650	{{code language="assembler"}}
1651	1651	AZ$CSR = 177220 ; регистр команд и состояния (CSR)
...	...	@@ -1724,7 +1724,7 @@
1724	1724
1725	1725	Код команды 026,  данная команда осуществляет непосредственный обмен с Hall of Fame
1726	1726
1727		-Example program:
	1737	+Пример программы
1728	1728
1729	1729	{{code language="assembler"}}
1730	1730	;4. авторизация пользователя