Skip to Content
Last modified by Max on 2025/03/02 15:18
From version 2.77
edited by Max
on 2025/02/25 17:22
Change comment: (Autosaved)
To version 2.94
edited by Max
on 2025/02/25 18:37
Change comment: (Autosaved)

Summary

Details

Page properties
Content
... ... @@ -1382,298 +1382,291 @@
1382 1382  Example program:
1383 1383  
1384 1384  {{code language="assembler"}}
1385 + call AZRST; reset
1385 1385  
1386 - 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
1387 1387  
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); декрементируем
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
1398 1398  
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
1399 1399  
1400 - ; устанавливаем файл на чтение
1401 - mov #50,(R1); устанавливаем файл на чтение
1402 -2$: TSTB (R1); проверяем результат выполнения
1403 - 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
1404 1404  
1421 +; read the file
1422 + mov R1,R4; R1 holds the file length
1423 + MOV #AZ$CSR,R1
1424 + mov #BUFFL,R5
1405 1405  
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); читаем с контроллера
1426 + bit #1,R4; if an odd number of bytes
1427 + beq 47$
1428 + inc R4; add 1 more byte as we read words
1414 1414  
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
1430 +47$: tst R4
1431 + beq 45$ ; nothing left to read - exit
1423 1423  
1424 - ; читаем файл
1425 - mov R1,R4; в R1 осталась длина файла
1426 - MOV #AZ$CSR,R1
1427 - 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
1428 1428  
1429 - bit #1,R4; если нечетное число байт
1430 - beq 47$
1431 - inc R4; добавим еще 1 байт тк читаем словами
1440 + cmp R4,#512.; compare with buffer size in bytes
1441 + Blos 44$ ; less than buffer size left
1432 1432  
1433 -47$: tst R4
1434 - 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$
1435 1435  
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$
1436 1436  
1437 - mov #52,(R1); читаем блок в буфер
1438 -4$: TSTB (R1); проверяем результат выполнения
1439 - BPL 4$ ; ждем
1440 - mov #22,(R1); будем читать буфер
1441 -51$: TSTB (R1); проверяем результат выполнения
1442 - BPL 51$ ; ждем
1459 +45$: clr (R5); set end of file marker
1443 1443  
1444 - cmp R4,#512.; сравниваем c размером буфера в байтах
1445 - Blos 44$ ; осталось меньше чем буфер
1461 +; file read - display on screen
1462 + .print #STMS4
1463 + .print #BUFFL
1464 + .print #STMS5
1446 1446  
1466 + mov #110,@#AZ$CSR; enable network
1467 + .Exit
1447 1447  
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
1474 1474  {{/code}}
1475 1475  
1476 1476  
1477 1477  
1478 -== **053:** установить имя файла который будем писать ==
1473 +== 053: set the name of the file that we will write ==
1479 1479  
1480 -Код команды 053,  данная команда открывает файл на запись, получает параметры открытия (или ошибки).
1475 +Command code 053, this command opens a file for writing, receives opening parameters (or errors).
1481 1481  
1482 -== **054:** установка длины файла ==
1477 +== 054: Set file length ==
1483 1483  
1484 -Код команды 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.
1485 1485  
1486 -== **055:** записать в файл данные из буфера ==
1481 +== 055: write data from buffer to file ==
1487 1487  
1488 -Код команды 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.
1489 1489  
1490 -Схема подачи команд при записи вот такая
1491 -**023** - заливаем имя файла в буфер
1492 -**053** - устанавливаем файл на чтение
1493 -**051 **- статус открытия/создания файла
1494 -если ошибка - повторяем сначала 023 053 051
1495 -если все ok - идем дальше
1496 -**054** - установка длины файла, те надо сразу объявить какая у нас будет длина файла
1497 -**023** - заливаем блок данных в буфер
1498 -**055** - пишем из буфера в файл
1499 -пары 023 055 повторяем нужное количество раз дабы записать весь файл
1500 -как файл будет записан - последняя 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
1501 1501  
1502 1502  
1503 1503  Example program:
1504 1504  
1505 1505  {{code language="assembler"}}
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) ; переходим на регистр команд
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
1517 1517  
1518 - ; устанавливаем файл на запись
1519 - mov #53,(R1); устанавливаем файл на запись
1520 -12$: TSTB (R1) ; проверяем результат выполнения
1521 - 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
1522 1522  
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
1523 1523  
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); читаем с контроллера
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
1532 1532  
1533 - ; тут надо проверить - если файл создан то оба слова нулевые
1534 - mov #STATS,R3
1535 - TST (R3)+
1536 - BNE 66$
1537 - TST (R3)
1538 - BEQ 60$
1539 -66$: .print #ERRMS1 ; печать ошибки
1540 - .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
1541 1541  
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); пишем в контроллер
1545 + tst -(R1) ; move to command register
1550 1550  
1551 - tst -(R1) ; переходим на регистр команд
1547 +; write file
1548 + mov @#FILSZ,R4; file length
1549 + MOV #AZ$CSR,R1
1550 + mov #BUFFL,R5; file buffer
1552 1552  
1552 + bit #1,R4 ; if an odd number of bytes
1553 + beq 147$
1554 + inc R4 ; add 1 more byte since reading words
1553 1553  
1556 +147$: tst R4 ; check length
1557 + beq 145$ ; nothing left to write - exit
1554 1554  
1555 - ; пишем файл
1556 - mov @#FILSZ,R4; длина файла
1557 - MOV #AZ$CSR,R1
1558 - mov #BUFFL,R5; буфер файла
1559 + mov #23,(R1); write to buffer
1560 +151$: TSTB (R1) ; check execution result
1561 + BPL 151$ ; wait
1559 1559  
1560 - bit #1,R4 ; если нечетное число байт
1561 - beq 147$
1562 - inc R4 ; добавим еще 1 байт тк читаем словами
1563 + cmp R4,#512.; compare with buffer size in bytes
1564 + Blos 144$ ; less than buffer size left
1563 1563  
1564 -147$: tst R4 ; проверим длину
1565 - 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
1566 1566  
1567 - mov #23,(R1); будем писать в буфер
1568 -151$: TSTB (R1) ; проверяем результат выполнения
1569 - 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
1570 1570  
1571 - cmp R4,#512.; сравниваем c размером буфера в байтах
1572 - 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$
1573 1573  
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) ; переходим на регистр команд
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
1581 1581  
1582 - mov #55,(R1); запись буфера в файл
1583 -104$: TSTB (R1) ; проверяем результат выполнения
1584 - BPL 104$ ; ждем
1585 - br 147$ ; в начало
1591 +145$: .print #STMSE ; end
1592 + mov #110,@#AZ$CSR; enable network
1593 + .Exit ; exit
1586 1586  
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 ; выходим
1602 1602  {{/code}}
1603 1603  
1604 -**[[пример полностью в виде утилиты 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]]**
1605 1605  
1606 1606  
1607 -== **056: Получить данные по размеру карты в буфер sizecard** ==
1600 +== 056: Get data on the size of the map into the sizecard buffer ==
1608 1608  
1609 -Код команды 056,  данная команда читает параметры MicroSD карты в буфер sizecard
1602 +Command code 056, this command reads the parameters of the MicroSD card into the sizecard buffer
1610 1610  
1611 -== **057: Чтение буфера sizecard** ==
1604 +== 057: Reading sizecard buffer ==
1612 1612  
1613 -Код команды 057,  данная команда отдает буфер sizecard (2 слова)
1606 +Command code 057, this command returns the sizecard buffer (2 words)
1614 1614  
1615 -буфер sizecard содержит 2 слова 16bit
1616 -первое слово - общий объем карты доступный для FAT в МБ
1617 -второе слово - свободный объем на карте в МБ
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 1618  
1619 -Пример программы:
1612 +Example program:
1620 1620  
1621 1621  {{code language="assembler"}}
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
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 +
1640 1640  {{/code}}
1641 1641  
1642 -Пример данных
1643 -035521 - всего на карточке мегабайт - 15185.
1644 -035417 - свободно мегабайт - 15119.
1645 -
1636 +Example data
1637 +035521 - total megabytes on the card - 15185.
1638 +035417 - free megabytes - 15119.
1646 1646  
1647 -= **Блок команд API Hall of Fame** =
1640 += Hall of Fame API Command Block =
1648 1648  
1649 -Данный блок команд предназначен для взаимодействия с сервером [[Hall of Fame>>https://forum.maxiol.com/index.php?showtopic=5642]]
1642 +This block of commands is intended for interaction with the server [[Hall of Fame>>https://forum.maxiol.com/index.php?showtopic=5642]]
1650 1650  
1651 1651  == **025: Инициализация Hall of Fame (HOF)** ==
1652 1652  
1653 -Код команды 025,  данная команда устанавливает соединение с сервером Hall of Fame, инициализирует шифрованный тоннель и подготавливает API к работе.
1646 +Command code 025, this command establishes a connection to the Hall of Fame server, initializes the encrypted tunnel and prepares the API for work.
1654 1654  
1655 -Пример программы
1648 +Example program:
1656 1656  
1657 1657  {{code language="assembler"}}
1658 -AZ$CSR = 177220 ; регистр команд и состояния (CSR)
1659 -AZ$DR = 177222 ; регистр данных (DR)
1651 +AZ$CSR = 177220 ; command and status register (CSR)
1652 +AZ$DR = 177222 ; data register (DR)
1660 1660  
1661 -; буфера
1662 -SNDBUF: .BLKW 256. ; буфер передачи
1663 -RCVBUF: .BLKW 256. ; буфер приема ответа
1654 +; buffers
1655 +SNDBUF: .BLKW 256. ; send buffer
1656 +RCVBUF: .BLKW 256. ; receive buffer
1664 1664  SIDMEM: .BLKB 34. ; SID
1665 -SIDCST: .ASCII \{"SID":"\ ; заголовок SID-а
1658 +SIDCST: .ASCII \{"SID":"\ ; SID header
1666 1666   .even
1667 1667  
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 -
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 +
1677 1677   mov R5, -(SP)
1678 1678   mov R4, -(SP)
1679 1679   mov R3, -(SP)
... ... @@ -1681,29 +1681,29 @@
1681 1681   mov R1, -(SP)
1682 1682   mov R0, -(SP)
1683 1683  
1684 - mov #3,R5 ; количество попыток
1677 + mov #3,R5 ; number of attempts
1685 1685  
1686 1686  220$: mov #AZ$CSR,R1
1687 - clr (R1) ; Пошлем команду "Сброс"
1688 -221$: tstb (R1) ; Проверим готовность контроллера
1689 - bpl 221$ ; Если не готов ждем
1680 + clr (R1) ; Send "Reset" command
1681 +221$: tstb (R1) ; Check controller readiness
1682 + bpl 221$ ; If not ready, wait
1690 1690  
1691 - mov #25,(R1) ; инициализация - команда 025
1692 -20$: tstb (R1) ; проверяем результат выполнения
1693 - bpl 20$ ; ждем
1684 + mov #25,(R1) ; initialization - command 025
1685 +20$: tstb (R1) ; check execution result
1686 + bpl 20$ ; wait
1694 1694  
1695 - ; получим результат
1696 - mov #22,(R1) ; отдать на шину считанный блок памяти из буфера
1697 -21$: tstb (R1) ; проверяем результат выполнения
1698 - bpl 21$ ; ждем
1699 - tst (R1)+ ; инкрементируем
1688 + ; Retrieve the result
1689 + mov #22,(R1) ; output the read memory block from buffer to the bus
1690 +21$: tstb (R1) ; check execution result
1691 + bpl 21$ ; wait
1692 + tst (R1)+ ; increment
1700 1700   mov #SNDBUF,R3
1701 - mov #256.,R2 ; читаем 256. слов; первое слово - результат чтения
1702 -22$: mov (R1),(R3)+ ; читаем блок слов в память
1694 + mov #256.,R2 ; read 256 words; first word is the read result
1695 +22$: mov (R1),(R3)+ ; read block of words into memory
1703 1703   sob R2,22$
1704 1704  
1705 1705  
1706 - ; надо понять - есть ли SID
1699 + ; Determine if SID exists
1707 1707   mov #4,R0
1708 1708   mov #SNDBUF,R1
1709 1709   mov #SIDCST,R2
... ... @@ -1712,11 +1712,11 @@
1712 1712   sob R0,23$
1713 1713   clr R5
1714 1714   inc R5
1715 - br 26$ ; успешно
1708 + br 26$ ; success
1716 1716  
1717 -24$: ; SID не найден!
1710 +24$: ; SID not found!
1718 1718   sob R5,220$
1719 - clr R5 ; ошибка - нет SID-а
1712 + clr R5 ; error - no SID
1720 1720  
1721 1721  26$: mov (SP)+, R0
1722 1722   mov (SP)+, R1
... ... @@ -1725,69 +1725,71 @@
1725 1725   mov (SP)+, R4
1726 1726   mov (SP)+, R5
1727 1727   return
1721 +
1728 1728  {{/code}}
1729 1729  
1730 -== **026: обмен с Hall of Fame (HOF)** ==
1724 +== 026: Exchange with Hall of Fame (HOF) ==
1731 1731  
1732 -Код команды 026,  данная команда осуществляет непосредственный обмен с Hall of Fame
1726 +Command code 026, this command makes a direct exchange with Hall of Fame
1733 1733  
1734 -Пример программы
1728 +Example program:
1735 1735  
1736 1736  {{code language="assembler"}}
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"}
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"}
1746 1746  
1747 - ; загоняем команду CMD04
1748 - mov #CMD04,R1
1749 - mov #ADRMEM,R2
1750 - add #42.,R2 ; cдвигаем указатель на длину блока с SID
1751 -33$: movb (R1)+,(R2)+
1752 - bne 33$
1741 + ; load command CMD04
1742 + mov #CMD04,R1
1743 + mov #ADRMEM,R2
1744 + add #42.,R2 ; shift the pointer to the SID block length
1745 +33$: movb (R1)+,(R2)+
1746 + bne 33$
1753 1753  
1754 - .Print #ADRMEM
1748 + .Print #ADRMEM
1755 1755  
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) ; декрементируем
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
1771 1771  
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$ ; ждем
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
1779 1779  
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$
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 +
1791 1791  {{/code}}
1792 1792  
1793 1793