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

Summary

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

Details

Page properties

Content

...	...	@@ -1034,15 +1034,14 @@
1034	1034	{{code language="assembler"}}
1035	1035	;--------------------------------------------------
1036	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
	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	1041	SCR_MEM_CONF = SCR_PAGE_CONF+4. ; here is the memory configuration from the registers - 22 words
1042	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
	1043	+SCR_PAL = SCR_VGA_CONF+20. ; here 338. values (words) of palette 338 words
1044	1044	;--------------------------------------------------
1045		-
1046	1046	; trap 41 - preparation of default information for screenshot functionality
1047	1047	PrepSRC: jsr R5, PUSHA ; batch saving of registers
1048	1048	mov @#177326,-(SP) ; save page 130k which was before the call
...	...	@@ -1138,205 +1138,206 @@
1138	1138	Example program
1139	1139
1140	1140	{{code language="assembler"}}
1141		-; обновим информацию в хидере скриншота
	1140	+; update the information in the screenshot header
1142	1142	;--------------------------------------------------
1143		-; карта 76й страницы - туда мы готовим данные для команды скринщотов
1144		- SPAGE = 170000 ; 76ую страницу цепляем на место 77й временно - те в окно 130000
1145		- STAG = SPAGE+0 ; тут вход - 240 - 1 слово
1146		- SADDRC = STAG+2 ; сюда команду с адресами - адрес+длина 24 бита - 4 слова
1147		- SPAGEC = SADDRC+8. ; сюда команду со страницами - начальная страница и количество страниц - 2 слова
1148		- SMEMC = SPAGEC+4. ; cюда конфигурацию памяти из регистров - 22 слова
1149		- SVGAC = SMEMC+44. ; сюда конфигурацию видеоконтроллера - 10 cлов
1150		- 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
1151	1151	;--------------------------------------------------
	1151	+ mov @#177326,R5 ; save page 130k which was before the call
	1152	+ mov #76,@#177336 ; hook the 76th page into the window
1152	1152
1153		- mov @#177326,R5 ; сохраним страницу 130k которая была до вызова
1154		- mov #76,@#177336 ; цепляем 76ую страницу в окно
1155		-
1156		- ;конфигурация видеоконтроллера
	1154	+ ;video controller configuration
1157	1157	; 177230-177256
1158	1158	mov #SVGAC,R4
1159	1159
1160		- mov @#177230,(R4)+;177230 - регистр управления
1161		- mov @#177232,(R4)+;177232 - регистр - верхняя страница (слой 0)
1162		- mov @#177240,(R4)+;177240 - регистр - средняя страница (слой 1)
1163		- mov @#177242,(R4)+;177242 - регистр - нижняя страница (слой 2)
1164		- mov @#177244,(R4)+;177244 - регистр вертикального скролинга слой 2
1165		- mov @#177246,(R4)+;177246 - регистр вертикального скролинга слой 1
1166		- mov @#177250,(R4)+;177250 - регистр вертикального скролинга слой 0
1167		- mov @#177252,(R4)+;177252 - регистр гозизонтального скролинга слой 0
1168		- mov @#177254,(R4)+;177254 - регистр гозизонтального скролинга слой 1
1169		- 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
1170	1170
1171		- mov R5,@#177336; вернем страницу с которой был вызов
	1169	+ mov R5,@#177336; return the page from which the call was made
1172	1172
1173	1173
1174	1174	;-------------------------
1175		- MOV #AZ$CSR,R3 ; Готовим CSR контроллера
1176		- MOV #AZ$DR,R4 ; Готовим DR контроллера
1177		-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
1178	1178	TSTB (R3)
1179	1179	BPL 20$
1180	1180
1181		- ; очистим блок памяти для имени - дабы система сделала дефолтное имя файла
1182		- mov #23,(R3) ; командуем что будем писать данные в буфер
1183		-128$: TSTB (R3) ; проверяем результат выполнения
1184		- 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
1185	1185	clr R1
1186	1186
1187	1187	mov #256.,R2 ;
1188		-129$: mov R1,(R4) ; отдаем в контроллер
	1186	+129$: mov R1,(R4) ; give to the controller
1189	1189	sob R2,129$
1190	1190
1191	1191
1192		- MOV #044,(R3) ; команда скриншот
	1190	+ MOV #044,(R3) ; screenshot command
1193	1193	22$: TSTB (R3) ;
1194	1194	BPL 22$ ;
1195	1195
1196		- ; получим имя скриншота
1197		- mov #22,(R3) ; отдать на шину считанный блок памяти из буфера
1198		-121$: tstb (R3) ; проверяем результат выполнения
1199		- 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
1200	1200
1201	1201	mov #BUF,R1
1202		- mov #256.,R2 ; читаем 256. слов; первое слово - результат чтения
1203		-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
1204	1204	sob R2,122$
1205	1205
1206	1206	.PRINT #RESOK
1207	1207	.Print #BUF
1208	1208
1209		- mov #110,@#AZ$CSR; включаем сеть по-умолчанию сеть должна быть постоянно включена
	1207	+ mov #110,@#AZ$CSR; enable the network by default, the network should be constantly enabled
1210	1210	.Exit
1211	1211	{{/code}}
1212	1212
1213		-Для распаковки скриншота можно использовать вот эту утилиту
	1211	+To unpack a screenshot, you can use this utility - [[https:~~/~~/master.pdp-11.ru/screen_unpack/>>https://master.pdp-11.ru/screen_unpack/]]
1214	1214
1215	1215
1216	1216
1217		-= **Команды для работы со стеком TCP/IP** =
	1215	+= Commands for working with the TCP/IP stack =
1218	1218
1219		-следующие команды работают с буфером информации TCP/IP cтека.
	1217	+The following commands operate on the TCP/IP stack information buffer.
1220	1220
1221		-== **040: Получить ip адрес и прочие настройки стека TCP/IP в буфер** ==
	1219	+== 040: Get IP address and other TCP/IP stack settings to buffer ==
1222	1222
1223		-Код команды 040,  данная команда заполняет буфер информацией с TCP/IP cтека текущей (фактической) информацией.
	1221	+Command code 040, this command fills the buffer with information from the TCP/IP stack with current (actual) information.
1224	1224
1225		-== **041: Чтение буфера ip адреса** ==
	1223	+== 041: Reading ip address buffer ==
1226	1226
1227		-Код команды 041,  данная команда передает буфер на шину
	1225	+Command code 041, this command transfers the buffer to the bus
1228	1228
1229		-эта пара команд позволяет получить текущую информацию со стека
	1227	+This pair of commands allows you to get current information from the stack
1230	1230
1231		-* IP адрес
1232		-* MASK маску
1233		-* GW гейтвей
1234		-* NTP адрес NTP-сервера
1235		-* DNS1 адрес основного DNS
1236		-* 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
1237	1237
1238		-соответственно это 12 слов
	1236	+accordingly it is 12 words
1239	1239
1240		-Пример программы:
	1238	+Example program:
1241	1241
1242	1242	{{code language="assembler"}}
1243		-; trap 52 - чтение блока IP адресов в блок памяти IPADDDBLOCK (8. ячеек)
1244		-; результат в R3 =0 error, иначе адрес куда считано (IPADDDBLOCK)
1245		-GetIPaddrs: push R1
1246		- push R2
1247		- call AZreset; сбросим
1248		- tst R1
1249		- bne 0ERR$
1250		- MOV #AZ$CSR,R1
1251		- mov #40,(R1)
1252		-0$: TSTB (R1); прочитать адреса в свою память
1253		- BPL 0$; ждем
1254		- mov #41,(R1)
1255		-1$: TSTB (R1); подготовить буфер
1256		- BPL 1$; ждем
1257		- TST (R1)+; инкрементируем
1258		- mov #IPADDDBLOCK,R3
1259		- mov #12.,R2
1260		-2$: mov (R1),(R3)+; читаем блок слов в память
1261		- sob R2,2$
1262		- mov #IPADDDBLOCK,R3; успешно
1263		- br 0END$
1264		-0ERR$: CLR R3
1265		-0END$: pop R2
1266		- pop R1
1267		- 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	+
1268	1268	{{/code}}
1269	1269
1270		-Пример данных
	1269	+Example return data:
1271	1271
1272	1272	{{info}}
1273		-Примеры данных - возвращаемые слова в восьмеричном формате
1274		-124300 116400 - IP адрес 192.168.0.157
1275		-177777 000377 - MASK маску 255.255.255.0
1276		-124300 000400 - GW гейтвей 192.168.0.1
1277		-124300 000400 - NTP адрес NTP-сервера 192.168.0.1
1278		-124300 050000 - DNS1 адрес основного DNS 192.168.0.90
1279		-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
1280	1280	{{/info}}
1281	1281
1282		-== **043: чтение MAC-адреса в ip буфер** ==
	1281	+== 043: Read MAC address into ip buffer ==
1283	1283
1284		-Код команды 043, данная команда читает текущий фактический MAC адрес в буфер IP адресов
1285		-те сначала 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
1286	1286
1287		-Пример программы:
	1285	+Example program:
1288	1288
1289	1289	{{code language="assembler"}}
1290		-; trap 72 - чтение MAC адреса в блок памяти IPADDDBLOCK (12. ячеек)
1291		-; результат в R3 =0 error, иначе адрес куда считано (IPADDDBLOCK)
1292		-GetMACaddrs: push R1
1293		- push R2
1294		- call AZreset ; сбросим
1295		- tst R1
1296		- bne 0ERR$
1297		- MOV #AZ$CSR,R1
1298		- mov #43,(R1)
1299		-0$: TSTB (R1) ; прочитать адреса в свою память
1300		- BPL 0$ ; ждем
1301		- mov #41,(R1)
1302		-1$: TSTB (R1) ; подготовить буфер
1303		- BPL 1$ ; ждем
1304		- TST (R1)+ ; инкрементируем
1305		- mov #IPADDDBLOCK,R3
1306		- mov #12.,R2
1307		-2$: mov (R1),(R3)+ ; читаем блок слов в память
1308		- sob R2,2$
1309		- mov #IPADDDBLOCK,R3; успешно
1310		- br 0END$
1311		-0ERR$: CLR R3
1312		-0END$: pop R2
1313		- pop R1
1314		- 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	+
1315	1315	{{/code}}
1316	1316
1317	1317
1318	1318
1319		-= **Команды для работы с MicroSD картой на файловом уровне** =
	1318	+= Commands for working with a MicroSD card at the file level =
1320	1320
1321	1321
1322		-Данные команды предназначены для работы с 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.
1323	1323
1324		-Эти команды используют буфер 256. слов который задействован в интерфейсе работы с энергонезависимой памятью (см выше команды 022 023)
1325		-\\Ограничения - длина полного пути к файлу  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)
1326	1326
1327		-== **050: Установить имя файла который будем читать** ==
	1325	+Limitations - the length of the full path to the file is 256 bytes
1328	1328
1329		-Код команды 050,  данная команда устанавливает имя файла который будем читать, при этом производится открытие файла на чтение, а также получение его свойств.
	1327	+== 050: Set the name of the file we will read ==
1330	1330
1331		-== **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.
1332	1332
1333		-Код команды 051,  данная команда передает на МПИ размер файла или ошибку его чтения. Размер файла 31бит, старший бит является признаком ошибки. Соответственно максимальный размер файлов с которыми можно работать через этот интерфейс ограничен 2^31 байт (2GB).
	1331	+== 051: Get file size for reading (or its status) on BUS ==
1334	1334
1335		-формирование ошибки выглядит так:
1336		-sizeanyfile=1<<31 + FFres; ~/~/ если установлен старший бит 32х битного слова - то в младшей части код ошибки
1337		-\\FFres = ошибка FatFS
1338		-
	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).
1339	1339
	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,288 +1364,280 @@
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: Читать блок установленного файла в буфер** ==
	1367	+== 052: Read a block of a set file into a buffer ==
1368	1368
1369		-Код команды 052,  данная команда осуществляет чтение файла в буфер энергонезависимой памяти.
	1369	+Command code 052, this command reads a file into a non-volatile memory buffer.
1370	1370
1371		-В итоге схема чтения файла выглядит вот так
1372		-**023** - заливаем имя файла в буфер
1373		-**050** - устанавливаем файл на чтение
1374		-**051 **- читаем длину файла или ошибку открытия файла
1375		-если ошибка - повторяем сначала 023 050 051
1376		-если все ok - приступаем к чтению файла
1377		-**052** - читает блок файла в буфер
1378		-**022 **- забираем данные из буфера
1379		-пары 052 022 повторяем нужное количество раз дабы считать весь файл
1380		-как файл будет прочтен - последняя 052 команда закроет его автоматически.
1381		-
	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.
1382	1382
1383		-Пример программы
	1382	+Example program:
1384	1384
1385	1385	{{code language="assembler"}}
	1385	+ call AZRST; reset
1386	1386
1387		- 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
1388	1388
1389		-; заливаем в буфер имя файла
1390		-7$: mov #23,(R1); командуем что будем писать данные в буфер
1391		-5$: TSTB (R1); проверяем результат выполнения
1392		- BPL 5$ ; ждем
1393		- TST (R1)+; инкрементируем
1394		- mov #FILNM,R3
1395		-1$: mov (R3),(R1); отдаем в контроллер
1396		- tst (R3)+
1397		- bne 1$
1398		- 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
1399	1399
	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
1400	1400
1401		- ; устанавливаем файл на чтение
1402		- mov #50,(R1); устанавливаем файл на чтение
1403		-2$: TSTB (R1); проверяем результат выполнения
1404		- 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
1405	1405
	1421	+; read the file
	1422	+ mov R1,R4; R1 holds the file length
	1423	+ MOV #AZ$CSR,R1
	1424	+ mov #BUFFL,R5
1406	1406
1407		- ; читаем длину файда
1408		- mov #51,(R1); устанавливаем файл на чтение
1409		-3$: TSTB (R1); проверяем результат выполнения
1410		- BPL 3$ ; ждем
1411		- TST (R1)+; инкрементируем
1412		- mov #FILSZ,R3
1413		- mov (R1),(R3)+; читаем с контроллера
1414		- 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
1415	1415
1416		- ; выведем длину файла на экран
1417		- clr R0
1418		- mov #FILSZ+2,R3
1419		- mov (R3),R1
1420		- call DNOZ
1421		- mov -(R3),R1
1422		- call DNOZ
1423		- .print #STMS2
	1430	+47$: tst R4
	1431	+ beq 45$ ; nothing left to read - exit
1424	1424
1425		- ; читаем файл
1426		- mov R1,R4; в R1 осталась длина файла
1427		- MOV #AZ$CSR,R1
1428		- 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
1429	1429
1430		- bit #1,R4; если нечетное число байт
1431		- beq 47$
1432		- inc R4; добавим еще 1 байт тк читаем словами
	1440	+ cmp R4,#512.; compare with buffer size in bytes
	1441	+ Blos 44$ ; less than buffer size left
1433	1433
1434		-47$: tst R4
1435		- 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$
1436	1436
	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$
1437	1437
1438		- mov #52,(R1); читаем блок в буфер
1439		-4$: TSTB (R1); проверяем результат выполнения
1440		- BPL 4$ ; ждем
1441		- mov #22,(R1); будем читать буфер
1442		-51$: TSTB (R1); проверяем результат выполнения
1443		- BPL 51$ ; ждем
	1459	+45$: clr (R5); set end of file marker
1444	1444
1445		- cmp R4,#512.; сравниваем c размером буфера в байтах
1446		- Blos 44$ ; осталось меньше чем буфер
	1461	+; file read - display on screen
	1462	+ .print #STMS4
	1463	+ .print #BUFFL
	1464	+ .print #STMS5
1447	1447
	1466	+ mov #110,@#AZ$CSR; enable network
	1467	+ .Exit
1448	1448
1449		- .print #STMS1
1450		- mov #256.,R2
1451		- TST (R1)+; переходим на регистр данных
1452		-46$: mov (R1),(R5)+; читаем в буфер
1453		- sob R2,46$
1454		- sub #512.,R4; вычитаем
1455		- TST -(R1); переходим на регистр команд
1456		- br 47$
1457		-
1458		-44$: .print #STMS3
1459		- mov R4,R2
1460		- asr R2 ; /2 тк читаем словами
1461		- TST (R1)+; переходим на регистр данных
1462		-43$: mov (R1),(R5)+; читаем в буфер
1463		- sob R2,43$
1464		-
1465		-
1466		-45$: clr (R5); проставим конец файла
1467		- ; файл считан - выводим на экран
1468		- .print #STMS4
1469		- .print #BUFFL
1470		- .print #STMS5
1471		-
1472		-
1473		- mov #110,@#AZ$CSR; включаем сеть
1474		- .Exit
1475	1475	{{/code}}
1476	1476
1477	1477
1478	1478
1479		-== **053:** установить имя файла который будем писать ==
	1473	+== 053: set the name of the file that we will write ==
1480	1480
1481		-Код команды 053,  данная команда открывает файл на запись, получает параметры открытия (или ошибки).
	1475	+Command code 053, this command opens a file for writing, receives opening parameters (or errors).
1482	1482
1483		-== **054:** установка длины файла ==
	1477	+== 054: Set file length ==
1484	1484
1485		-Код команды 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.
1486	1486
1487		-== **055:** записать в файл данные из буфера ==
	1481	+== 055: write data from buffer to file ==
1488	1488
1489		-Код команды 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.
1490	1490
1491		-Схема подачи команд при записи вот такая
1492		-**023** - заливаем имя файла в буфер
1493		-**053** - устанавливаем файл на чтение
1494		-**051 **- статус открытия/создания файла
1495		-если ошибка - повторяем сначала 023 053 051
1496		-если все ok - идем дальше
1497		-**054** - установка длины файла, те надо сразу объявить какая у нас будет длина файла
1498		-**023** - заливаем блок данных в буфер
1499		-**055** - пишем из буфера в файл
1500		-пары 023 055 повторяем нужное количество раз дабы записать весь файл
1501		-как файл будет записан - последняя 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
1502	1502
1503	1503
1504		-Пример программы:
	1498	+Example program:
1505	1505
1506	1506	{{code language="assembler"}}
1507		-; заливаем в буфер имя файла
1508		- MOV #AZ$CSR,R1
1509		-17$: mov #23,(R1); командуем что будем писать данные в буфер
1510		-15$: TSTB (R1) ; проверяем результат выполнения
1511		- BPL 15$ ; ждем
1512		- TST (R1)+ ; переходим на регистр данных
1513		- mov #FILNM2,R3
1514		-11$: mov (R3),(R1); отдаем в контроллер
1515		- tst (R3)+
1516		- bne 11$
1517		- 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
1518	1518
1519		- ; устанавливаем файл на запись
1520		- mov #53,(R1); устанавливаем файл на запись
1521		-12$: TSTB (R1) ; проверяем результат выполнения
1522		- 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
1523	1523
	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
1524	1524
1525		- ; читаем статус создания файла
1526		- mov #51,(R1)
1527		-13$: TSTB (R1) ; проверяем результат выполнения
1528		- BPL 13$ ; ждем
1529		- TST (R1)+ ; переходим на регистр данных
1530		- mov #STATS,R3
1531		- mov (R1),(R3)+; читаем с контроллера
1532		- 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
1533	1533
1534		- ; тут надо проверить - если файл создан то оба слова нулевые
1535		- mov #STATS,R3
1536		- TST (R3)+
1537		- BNE 66$
1538		- TST (R3)
1539		- BEQ 60$
1540		-66$: .print #ERRMS1 ; печать ошибки
1541		- .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
1542	1542
1543		-60$: MOV #AZ$CSR,R1
1544		- mov #54,(R1); установим длину файла который будем писать
1545		-23$: TSTB (R1) ; проверяем результат выполнения
1546		- BPL 23$ ; ждем
1547		- TST (R1)+ ; переходим на регистр данных
1548		- mov #FILSZ,R3
1549		- mov (R3)+,(R1); пишем в контроллер
1550		- mov (R3),(R1); пишем в контроллер
	1545	+ tst -(R1) ; move to command register
1551	1551
1552		- tst -(R1) ; переходим на регистр команд
	1547	+; write file
	1548	+ mov @#FILSZ,R4; file length
	1549	+ MOV #AZ$CSR,R1
	1550	+ mov #BUFFL,R5; file buffer
1553	1553
	1552	+ bit #1,R4 ; if an odd number of bytes
	1553	+ beq 147$
	1554	+ inc R4 ; add 1 more byte since reading words
1554	1554
	1556	+147$: tst R4 ; check length
	1557	+ beq 145$ ; nothing left to write - exit
1555	1555
1556		- ; пишем файл
1557		- mov @#FILSZ,R4; длина файла
1558		- MOV #AZ$CSR,R1
1559		- mov #BUFFL,R5; буфер файла
	1559	+ mov #23,(R1); write to buffer
	1560	+151$: TSTB (R1) ; check execution result
	1561	+ BPL 151$ ; wait
1560	1560
1561		- bit #1,R4 ; если нечетное число байт
1562		- beq 147$
1563		- inc R4 ; добавим еще 1 байт тк читаем словами
	1563	+ cmp R4,#512.; compare with buffer size in bytes
	1564	+ Blos 144$ ; less than buffer size left
1564	1564
1565		-147$: tst R4 ; проверим длину
1566		- 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
1567	1567
1568		- mov #23,(R1); будем писать в буфер
1569		-151$: TSTB (R1) ; проверяем результат выполнения
1570		- 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
1571	1571
1572		- cmp R4,#512.; сравниваем c размером буфера в байтах
1573		- 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$
1574	1574
1575		- .print #STMS6 ; заливка полного блока
1576		- mov #256.,R2
1577		- TST (R1)+ ; переходим на регистр данных
1578		-146$: mov (R5)+,(R1); пишем в буфер контроллера
1579		- sob R2,146$
1580		- sub #512.,R4; вычитаем
1581		- 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
1582	1582
1583		- mov #55,(R1); запись буфера в файл
1584		-104$: TSTB (R1) ; проверяем результат выполнения
1585		- BPL 104$ ; ждем
1586		- br 147$ ; в начало
	1591	+145$: .print #STMSE ; end
	1592	+ mov #110,@#AZ$CSR; enable network
	1593	+ .Exit ; exit
1587	1587
1588		-144$: .print #STMS7 ; заливка последнего блока
1589		- TST (R1)+ ; переходим на регистр данных
1590		- mov R4,R2
1591		- asr R2 ; /2 тк пишем словами
1592		-143$: mov (R5)+,(R1); пишем в буфер контроллера
1593		- sob R2,143$
1594		-
1595		- TST -(R1) ; переходим на регистр команд
1596		- mov #55,(R1); запись пследнего буфера в файл
1597		-105$: TSTB (R1) ; проверяем результат выполнения
1598		- BPL 105$ ; ждем
1599		-
1600		-145$: .print #STMSE ; конец
1601		- mov #110,@#AZ$CSR; включаем сеть
1602		- .Exit ; выходим
1603	1603	{{/code}}
1604	1604
1605		-**[[пример полностью в виде утилиты 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]]**
1606	1606
1607	1607
1608		-== **056: Получить данные по размеру карты в буфер sizecard** ==
	1600	+== 056: Get data on the size of the map into the sizecard buffer ==
1609	1609
1610		-Код команды 056,  данная команда читает параметры MicroSD карты в буфер sizecard
	1602	+Command code 056, this command reads the parameters of the MicroSD card into the sizecard buffer
1611	1611
1612		-== **057: Чтение буфера sizecard** ==
	1604	+== 057: Reading sizecard buffer ==
1613	1613
1614		-Код команды 057,  данная команда отдает буфер sizecard (2 слова)
	1606	+Command code 057, this command returns the sizecard buffer (2 words)
1615	1615
1616		-буфер sizecard содержит 2 слова 16bit
1617		-первое слово - общий объем карты доступный для FAT в МБ
1618		-второе слово - свободный объем на карте в МБ
	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
1619	1619
1620		-Пример программы:
	1612	+Example program:
1621	1621
1622	1622	{{code language="assembler"}}
1623		-; trap 51 - получение объема SD карты всего/свободно в мегабайтах
1624		-; результат в R1 - всего; R2 - свободно
1625		-GetSizeSD: call AZreset; сбросим
1626		- tst R1
1627		- bne 0ERR$
1628		- MOV #AZ$CSR,R1
1629		- mov #56,(R1)
1630		-1$: TSTB (R1); подготовить буфер
1631		- BPL 1$; ждем
1632		- mov #57,(R1)
1633		-2$: TSTB (R1); подготовить буфер
1634		- BPL 2$; ждем
1635		- mov @#AZ$DR ,R1; всего мегабайт
1636		- mov @#AZ$DR ,R2; свободно мегабайт
1637		- return
1638		- clr R1
1639		- clr R2
1640		- 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	+
1641	1641	{{/code}}
1642	1642
1643		-Пример данных
1644		-035521 - всего на карточке мегабайт - 15185.
1645		-035417 - свободно мегабайт - 15119.
1646		-
	1636	+Example data
	1637	+035521 - total megabytes on the card - 15185.
	1638	+035417 - free megabytes - 15119.
1647	1647
1648		-= **Блок команд API Hall of Fame** =
	1640	+= Hall of Fame API Command Block =
1649	1649
1650	1650	Данный блок команд предназначен для взаимодействия с сервером [[Hall of Fame>>https://forum.maxiol.com/index.php?showtopic=5642]]
1651	1651
...	...	@@ -1653,7 +1653,7 @@
1653	1653
1654	1654	Код команды 025,  данная команда устанавливает соединение с сервером Hall of Fame, инициализирует шифрованный тоннель и подготавливает API к работе.
1655	1655
1656		-Пример программы
	1648	+Example program:
1657	1657
1658	1658	{{code language="assembler"}}
1659	1659	AZ$CSR = 177220 ; регистр команд и состояния (CSR)
...	...	@@ -1732,7 +1732,7 @@
1732	1732
1733	1733	Код команды 026,  данная команда осуществляет непосредственный обмен с Hall of Fame
1734	1734
1735		-Пример программы
	1727	+Example program:
1736	1736
1737	1737	{{code language="assembler"}}
1738	1738	;4. авторизация пользователя