Skip to Content
Last modified by Max on 2025/03/02 15:18
From version 2.93
edited by Max
on 2025/02/25 18:34
Change comment: There is no comment for this version
To version 2.77
edited by Max
on 2025/02/25 17:22
Change comment: (Autosaved)

Summary

Details

Page properties
Content
... ... @@ -1382,291 +1382,298 @@
1382 1382  Example program:
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
1386 + 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
1388 +; заливаем в буфер имя файла
1389 +7$: mov #23,(R1); командуем что будем писать данные в буфер
1390 +5$: TSTB (R1); проверяем результат выполнения
1391 + BPL 5$ ; ждем
1392 + TST (R1)+; инкрементируем
1393 + mov #FILNM,R3
1394 +1$: mov (R3),(R1); отдаем в контроллер
1395 + tst (R3)+
1396 + bne 1$
1397 + 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
1400 + ; устанавливаем файл на чтение
1401 + mov #50,(R1); устанавливаем файл на чтение
1402 +2$: TSTB (R1); проверяем результат выполнения
1403 + 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
1406 + ; читаем длину файда
1407 + mov #51,(R1); устанавливаем файл на чтение
1408 +3$: TSTB (R1); проверяем результат выполнения
1409 + BPL 3$ ; ждем
1410 + TST (R1)+; инкрементируем
1411 + mov #FILSZ,R3
1412 + mov (R1),(R3)+; читаем с контроллера
1413 + mov (R1),(R3); читаем с контроллера
1429 1429  
1430 -47$: tst R4
1431 - beq 45$ ; nothing left to read - exit
1415 + ; выведем длину файла на экран
1416 + clr R0
1417 + mov #FILSZ+2,R3
1418 + mov (R3),R1
1419 + call DNOZ
1420 + mov -(R3),R1
1421 + call DNOZ
1422 + .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
1424 + ; читаем файл
1425 + mov R1,R4; в R1 осталась длина файла
1426 + MOV #AZ$CSR,R1
1427 + mov #BUFFL,R5
1439 1439  
1440 - cmp R4,#512.; compare with buffer size in bytes
1441 - Blos 44$ ; less than buffer size left
1429 + bit #1,R4; если нечетное число байт
1430 + beq 47$
1431 + 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$
1433 +47$: tst R4
1434 + 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
1437 + mov #52,(R1); читаем блок в буфер
1438 +4$: TSTB (R1); проверяем результат выполнения
1439 + BPL 4$ ; ждем
1440 + mov #22,(R1); будем читать буфер
1441 +51$: TSTB (R1); проверяем результат выполнения
1442 + BPL 51$ ; ждем
1460 1460  
1461 -; file read - display on screen
1462 - .print #STMS4
1463 - .print #BUFFL
1464 - .print #STMS5
1444 + cmp R4,#512.; сравниваем c размером буфера в байтах
1445 + Blos 44$ ; осталось меньше чем буфер
1465 1465  
1466 - mov #110,@#AZ$CSR; enable network
1467 - .Exit
1468 1468  
1448 + .print #STMS1
1449 + mov #256.,R2
1450 + TST (R1)+; переходим на регистр данных
1451 +46$: mov (R1),(R5)+; читаем в буфер
1452 + sob R2,46$
1453 + sub #512.,R4; вычитаем
1454 + TST -(R1); переходим на регистр команд
1455 + br 47$
1456 +
1457 +44$: .print #STMS3
1458 + mov R4,R2
1459 + asr R2 ; /2 тк читаем словами
1460 + TST (R1)+; переходим на регистр данных
1461 +43$: mov (R1),(R5)+; читаем в буфер
1462 + sob R2,43$
1463 +
1464 +
1465 +45$: clr (R5); проставим конец файла
1466 + ; файл считан - выводим на экран
1467 + .print #STMS4
1468 + .print #BUFFL
1469 + .print #STMS5
1470 +
1471 +
1472 + mov #110,@#AZ$CSR; включаем сеть
1473 + .Exit
1469 1469  {{/code}}
1470 1470  
1471 1471  
1472 1472  
1473 -== 053: set the name of the file that we will write ==
1478 +== **053:** установить имя файла который будем писать ==
1474 1474  
1475 -Command code 053, this command opens a file for writing, receives opening parameters (or errors).
1480 +Код команды 053,  данная команда открывает файл на запись, получает параметры открытия (или ошибки).
1476 1476  
1477 -== 054: Set file length ==
1482 +== **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.
1484 +Код команды 054,  данная команда устанавливает ожидаемую длину файла, это нужно для корректного формирования файла на файловом уровне MicroSD карты, а также для организации передачи данных.
1480 1480  
1481 -== 055: write data from buffer to file ==
1486 +== **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.
1488 +Код команды 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
1490 +Схема подачи команд при записи вот такая
1491 +**023** - заливаем имя файла в буфер
1492 +**053** - устанавливаем файл на чтение
1493 +**051 **- статус открытия/создания файла
1494 +если ошибка - повторяем сначала 023 053 051
1495 +если все ok - идем дальше
1496 +**054** - установка длины файла, те надо сразу объявить какая у нас будет длина файла
1497 +**023** - заливаем блок данных в буфер
1498 +**055** - пишем из буфера в файл
1499 +пары 023 055 повторяем нужное количество раз дабы записать весь файл
1500 +как файл будет записан - последняя 055 команда закроет его автоматически
1496 1496  
1497 1497  
1498 1498  Example program:
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
1506 +; заливаем в буфер имя файла
1507 + MOV #AZ$CSR,R1
1508 +17$: mov #23,(R1); командуем что будем писать данные в буфер
1509 +15$: TSTB (R1) ; проверяем результат выполнения
1510 + BPL 15$ ; ждем
1511 + TST (R1)+ ; переходим на регистр данных
1512 + mov #FILNM2,R3
1513 +11$: mov (R3),(R1); отдаем в контроллер
1514 + tst (R3)+
1515 + bne 11$
1516 + 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
1518 + ; устанавливаем файл на запись
1519 + mov #53,(R1); устанавливаем файл на запись
1520 +12$: TSTB (R1) ; проверяем результат выполнения
1521 + 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
1524 + ; читаем статус создания файла
1525 + mov #51,(R1)
1526 +13$: TSTB (R1) ; проверяем результат выполнения
1527 + BPL 13$ ; ждем
1528 + TST (R1)+ ; переходим на регистр данных
1529 + mov #STATS,R3
1530 + mov (R1),(R3)+; читаем с контроллера
1531 + 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
1533 + ; тут надо проверить - если файл создан то оба слова нулевые
1534 + mov #STATS,R3
1535 + TST (R3)+
1536 + BNE 66$
1537 + TST (R3)
1538 + BEQ 60$
1539 +66$: .print #ERRMS1 ; печать ошибки
1540 + .exit
1544 1544  
1545 - tst -(R1) ; move to command register
1542 +60$: MOV #AZ$CSR,R1
1543 + mov #54,(R1); установим длину файла который будем писать
1544 +23$: TSTB (R1) ; проверяем результат выполнения
1545 + BPL 23$ ; ждем
1546 + TST (R1)+ ; переходим на регистр данных
1547 + mov #FILSZ,R3
1548 + mov (R3)+,(R1); пишем в контроллер
1549 + 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
1551 + 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
1555 + ; пишем файл
1556 + mov @#FILSZ,R4; длина файла
1557 + MOV #AZ$CSR,R1
1558 + mov #BUFFL,R5; буфер файла
1562 1562  
1563 - cmp R4,#512.; compare with buffer size in bytes
1564 - Blos 144$ ; less than buffer size left
1560 + bit #1,R4 ; если нечетное число байт
1561 + beq 147$
1562 + 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
1564 +147$: tst R4 ; проверим длину
1565 + 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
1567 + mov #23,(R1); будем писать в буфер
1568 +151$: TSTB (R1) ; проверяем результат выполнения
1569 + 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$
1571 + cmp R4,#512.; сравниваем c размером буфера в байтах
1572 + 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
1574 + .print #STMS6 ; заливка полного блока
1575 + mov #256.,R2
1576 + TST (R1)+ ; переходим на регистр данных
1577 +146$: mov (R5)+,(R1); пишем в буфер контроллера
1578 + sob R2,146$
1579 + sub #512.,R4; вычитаем
1580 + TST -(R1) ; переходим на регистр команд
1590 1590  
1591 -145$: .print #STMSE ; end
1592 - mov #110,@#AZ$CSR; enable network
1593 - .Exit ; exit
1582 + mov #55,(R1); запись буфера в файл
1583 +104$: TSTB (R1) ; проверяем результат выполнения
1584 + BPL 104$ ; ждем
1585 + br 147$ ; в начало
1594 1594  
1587 +144$: .print #STMS7 ; заливка последнего блока
1588 + TST (R1)+ ; переходим на регистр данных
1589 + mov R4,R2
1590 + asr R2 ; /2 тк пишем словами
1591 +143$: mov (R5)+,(R1); пишем в буфер контроллера
1592 + sob R2,143$
1593 +
1594 + TST -(R1) ; переходим на регистр команд
1595 + mov #55,(R1); запись пследнего буфера в файл
1596 +105$: TSTB (R1) ; проверяем результат выполнения
1597 + BPL 105$ ; ждем
1598 +
1599 +145$: .print #STMSE ; конец
1600 + mov #110,@#AZ$CSR; включаем сеть
1601 + .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]]**
1604 +**[[пример полностью в виде утилиты 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 ==
1607 +== **056: Получить данные по размеру карты в буфер sizecard** ==
1601 1601  
1602 -Command code 056, this command reads the parameters of the MicroSD card into the sizecard buffer
1609 +Код команды 056,  данная команда читает параметры MicroSD карты в буфер sizecard
1603 1603  
1604 -== 057: Reading sizecard buffer ==
1611 +== **057: Чтение буфера sizecard** ==
1605 1605  
1606 -Command code 057, this command returns the sizecard buffer (2 words)
1613 +Код команды 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
1615 +буфер sizecard содержит 2 слова 16bit
1616 +первое слово - общий объем карты доступный для FAT в МБ
1617 +второе слово - свободный объем на карте в МБ
1611 1611  
1612 -Example program:
1619 +Пример программы:
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 -
1622 +; trap 51 - получение объема SD карты всего/свободно в мегабайтах
1623 +; результат в R1 - всего; R2 - свободно
1624 +GetSizeSD: call AZreset; сбросим
1625 + tst R1
1626 + bne 0ERR$
1627 + MOV #AZ$CSR,R1
1628 + mov #56,(R1)
1629 +1$: TSTB (R1); подготовить буфер
1630 + BPL 1$; ждем
1631 + mov #57,(R1)
1632 +2$: TSTB (R1); подготовить буфер
1633 + BPL 2$; ждем
1634 + mov @#AZ$DR ,R1; всего мегабайт
1635 + mov @#AZ$DR ,R2; свободно мегабайт
1636 + return
1637 + clr R1
1638 + clr R2
1639 + return
1634 1634  {{/code}}
1635 1635  
1636 -Example data
1637 -035521 - total megabytes on the card - 15185.
1638 -035417 - free megabytes - 15119.
1642 +Пример данных
1643 +035521 - всего на карточке мегабайт - 15185.
1644 +035417 - свободно мегабайт - 15119.
1645 +
1639 1639  
1640 -= Hall of Fame API Command Block =
1647 += **Блок команд API Hall of Fame** =
1641 1641  
1642 -This block of commands is intended for interaction with the server [[Hall of Fame>>https://forum.maxiol.com/index.php?showtopic=5642]]
1649 +Данный блок команд предназначен для взаимодействия с сервером [[Hall of Fame>>https://forum.maxiol.com/index.php?showtopic=5642]]
1643 1643  
1644 1644  == **025: Инициализация Hall of Fame (HOF)** ==
1645 1645  
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.
1653 +Код команды 025,  данная команда устанавливает соединение с сервером Hall of Fame, инициализирует шифрованный тоннель и подготавливает API к работе.
1647 1647  
1648 -Example program:
1655 +Пример программы
1649 1649  
1650 1650  {{code language="assembler"}}
1651 -AZ$CSR = 177220 ; command and status register (CSR)
1652 -AZ$DR = 177222 ; data register (DR)
1658 +AZ$CSR = 177220 ; регистр команд и состояния (CSR)
1659 +AZ$DR = 177222 ; регистр данных (DR)
1653 1653  
1654 -; buffers
1655 -SNDBUF: .BLKW 256. ; send buffer
1656 -RCVBUF: .BLKW 256. ; receive buffer
1661 +; буфера
1662 +SNDBUF: .BLKW 256. ; буфер передачи
1663 +RCVBUF: .BLKW 256. ; буфер приема ответа
1657 1657  SIDMEM: .BLKB 34. ; SID
1658 -SIDCST: .ASCII \{"SID":"\ ; SID header
1665 +SIDCST: .ASCII \{"SID":"\ ; заголовок SID-а
1659 1659   .even
1660 1660  
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 -
1668 +HOFINI: ; инициализация HOF
1669 + ;результатом является такой JSON
1670 + ;{"SID":"хеш сессии","RESULT":"OK"}
1671 + ;или ошибка
1672 + ;{"RESULT":"ERROR","DESCRIPTION":"SERVER_ERROR"}
1673 + ;{"RESULT":"ERROR","DESCRIPTION":"CONNECTION_ERROR"}
1674 + ; результат помещается в SNDBUF
1675 + ; в R5 фиксация успешности - =1 есть SID, =0 нет SID-а
1676 +
1670 1670   mov R5, -(SP)
1671 1671   mov R4, -(SP)
1672 1672   mov R3, -(SP)
... ... @@ -1674,29 +1674,29 @@
1674 1674   mov R1, -(SP)
1675 1675   mov R0, -(SP)
1676 1676  
1677 - mov #3,R5 ; number of attempts
1684 + mov #3,R5 ; количество попыток
1678 1678  
1679 1679  220$: mov #AZ$CSR,R1
1680 - clr (R1) ; Send "Reset" command
1681 -221$: tstb (R1) ; Check controller readiness
1682 - bpl 221$ ; If not ready, wait
1687 + clr (R1) ; Пошлем команду "Сброс"
1688 +221$: tstb (R1) ; Проверим готовность контроллера
1689 + bpl 221$ ; Если не готов ждем
1683 1683  
1684 - mov #25,(R1) ; initialization - command 025
1685 -20$: tstb (R1) ; check execution result
1686 - bpl 20$ ; wait
1691 + mov #25,(R1) ; инициализация - команда 025
1692 +20$: tstb (R1) ; проверяем результат выполнения
1693 + bpl 20$ ; ждем
1687 1687  
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
1695 + ; получим результат
1696 + mov #22,(R1) ; отдать на шину считанный блок памяти из буфера
1697 +21$: tstb (R1) ; проверяем результат выполнения
1698 + bpl 21$ ; ждем
1699 + tst (R1)+ ; инкрементируем
1693 1693   mov #SNDBUF,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
1701 + mov #256.,R2 ; читаем 256. слов; первое слово - результат чтения
1702 +22$: mov (R1),(R3)+ ; читаем блок слов в память
1696 1696   sob R2,22$
1697 1697  
1698 1698  
1699 - ; Determine if SID exists
1706 + ; надо понять - есть ли SID
1700 1700   mov #4,R0
1701 1701   mov #SNDBUF,R1
1702 1702   mov #SIDCST,R2
... ... @@ -1705,11 +1705,11 @@
1705 1705   sob R0,23$
1706 1706   clr R5
1707 1707   inc R5
1708 - br 26$ ; success
1715 + br 26$ ; успешно
1709 1709  
1710 -24$: ; SID not found!
1717 +24$: ; SID не найден!
1711 1711   sob R5,220$
1712 - clr R5 ; error - no SID
1719 + clr R5 ; ошибка - нет SID-а
1713 1713  
1714 1714  26$: mov (SP)+, R0
1715 1715   mov (SP)+, R1
... ... @@ -1718,71 +1718,69 @@
1718 1718   mov (SP)+, R4
1719 1719   mov (SP)+, R5
1720 1720   return
1721 -
1722 1722  {{/code}}
1723 1723  
1724 -== 026: Exchange with Hall of Fame (HOF) ==
1730 +== **026: обмен с Hall of Fame (HOF)** ==
1725 1725  
1726 -Command code 026, this command makes a direct exchange with Hall of Fame
1732 +Код команды 026,  данная команда осуществляет непосредственный обмен с Hall of Fame
1727 1727  
1728 -Example program:
1734 +Пример программы
1729 1729  
1730 1730  {{code language="assembler"}}
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"}
1737 + ;4. авторизация пользователя
1738 + ;технически это отправка JSON
1739 + ;{"SID":"хеш сессии","CMD":"AUTH_USER","NIKNAME":"никнейм пользователя","PASSWORD":"пароль пользователя"}
1740 + ;ответ тоже JSON
1741 + ;{"SID":"хеш сессии","RESULT":"OK","UID":"хеш пользователя"}
1742 + ;или
1743 + ;{"SID":"хеш сессии","RESULT":"ERROR","DESCRIPTION":"USER_NOT_FOUND_OR_WRONG_PASSWORD"}
1744 + ;{"SID":"хеш сессии","RESULT":"ERROR","DESCRIPTION":"SERVER_ERROR"}
1745 + ;{"SID":"хеш сессии","RESULT":"ERROR","DESCRIPTION":"SESSION_NOT_EXISTS_OR_EXPIRED"}
1740 1740  
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$
1747 + ; загоняем команду CMD04
1748 + mov #CMD04,R1
1749 + mov #ADRMEM,R2
1750 + add #42.,R2 ; cдвигаем указатель на длину блока с SID
1751 +33$: movb (R1)+,(R2)+
1752 + bne 33$
1747 1747  
1748 - .Print #ADRMEM
1754 + .Print #ADRMEM
1749 1749  
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
1756 + .Print #HOF05
1757 + ; отсылаем команду и ждем ответа
1758 + ; закачиваем в буфер
1759 + MOV #AZ$CSR,R1
1760 +331$: TSTB (R1) ; Проверим готовность контроллера
1761 + BPL 331$ ; Если не готов ждем
1762 + mov #23,(R1) ; командуем что будем писать данные в буфер
1763 +34$: TSTB (R1) ; проверяем результат выполнения
1764 + BPL 34$ ; ждем
1765 + TST (R1)+ ; инкрементируем
1766 + mov #ADRMEM,R3
1767 + mov #256.,R2 ;
1768 +35$: mov (R3)+,(R1) ; отдаем в контроллер
1769 + sob R2,35$
1770 + tst -(R1) ; декрементируем
1765 1765  
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
1772 + ; обмен - команда 026
1773 + MOV #AZ$CSR,R1
1774 +361$: TSTB (R1) ; Проверим готовность контроллера
1775 + BPL 361$ ; Если не готов ждем
1776 + mov #26,(R1)
1777 +36$: TSTB (R1) ; проверяем результат выполнения
1778 + BPL 36$ ; ждем
1773 1773  
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 -
1780 + ; получим результат
1781 +371$: TSTB (R1) ; Проверим готовность контроллера
1782 + BPL 371$ ; Если не готов ждем
1783 + mov #22,(R1) ; отдать на шину буфер
1784 +37$: TSTB (R1) ; проверяем результат выполнения
1785 + BPL 37$ ; ждем
1786 + TST (R1)+ ; инкрементируем
1787 + mov #ADRMEM,R3
1788 + mov #256.,R2 ; читаем 256. слов; первое слово - результат чтения
1789 +38$: mov (R1),(R3)+ ; читаем блок слов в память
1790 + sob R2,38$
1786 1786  {{/code}}
1787 1787  
1788 1788