//  Доработанный тест контроллеров АльтПро с ДОЗУ 64-512КБ. Версия 4.74F
//  Изменения и нововведения в v4.1:
//  Тест памяти определяет только её количество, и корректность байтового доступа.
;* Тест режимов работает и на БК-0010(01), и на БК-0011М, вывод результатов теста режимов сделан более
;  человекопонятным.
;* Определяется тип контроллера по признаку в слове 0167776.
;Изменения и нововведения в v4.3:
;* Изменён тест определения количества памяти.
;* Добавлен тест проверки на битые ячейки памяти.
;Изменения и нововведения в v4.41:
;* Тест режимов перенесён вперёд, перед тестом памяти.
;* Добавлен свой знакогенератор, чтобы не зависеть от мониторов БК10 и БК11.
;* Добавлено определение версии прошивки 555РТ5.
;* v4.41 - попытка исправить ошибки скроллинга.
;Изменения и нововведения в v4.51:
;* Добавлен тест переключения страниц в проблемных режимах.
;* При заполнении экрана информацией выводится сообщение "нажмите любую клавишу" и программа ожидает 
;  нажатия любой клавиши, кроме СТОП и управляющих естественно.
;  работы.
;* v4.51 - Иногда, в нештатных случаях могли возникнуть ситуации, когда регистр 177130 на БК-0010
;  накладывался на ПЗУ бейсика и это приводило к неправильной работе теста. Теперь это исправлено,
;  возникающее прерывание по вектору 4 при записи в 177130 теперь игнорируется.
;Изменения и нововведения в v4.72F:
;* Добавлены тесты конструктивных особенностей: доступ к регистрам HDD, тест буфера ОЗУ для HDD, реакция на команду RESET, реакция на биты 2 (код 4) и 3 (код 10)
;* v4.71 - уточнение реакции на биты 2 и 3.
;* v4.72 - ещё одно уточнение реакции на биты 2 и 3.
;Изменения и нововведения в v4.73F:
;* Тест памяти на ошибки немного усложнён.
;Изменения и нововведения в v4.74F:
;* Тест памяти на ошибки изменён. Добавлено длинное тестирование случайными числами, 
;  с целью проверки стабильности, длительность длинного тестирования можно задать свою,
;  а так же совсем отменить. 


OFSF8=400
SYNCW=55000

SCRCRD=160
SCRY=156
SCRFNT=166
SCRLNC=164

LNGTST=400    ;ячейка, где хранится длительность длинного тестирования
DECBUF=410

//________________________________________________________________
//
beg:		mtps	#340			// запрещаем прерывания
		mov	#4, R4			//
		mov	#PZP1, (R4)+		// тест 10/11
		mfps	(R4)			// подготовили вектор 4
		mov	#177716, R5		//
		mov	#500, R2		//
		mov	#60, (R2)		// код рабочего режима 10
		mov	#42400, @#177662	// белая палитра, тут на 10 
						// случается исключение по вектору 4
		mov	#100140, (R2)		// признак и код рабочего режима 11M
		mov	#16000, (R5)		// страницы ANDOS
						//
pzp1:		clr	R1			//
		mov	(PC), R0		// почувств.клав.на 6 МГц: > 40000 SOB
		mov	#177130, R3		//
1$:		mov	R4, (R3)		// R4 == строб 6
		movb	(PC), (R5)		// звук (#200)
		mov	(R2), (R3)		// стандартный режим 10/11М
		mov	R1, (R3)		// строб 0
		movb    (PC), (R5)		// звук (#300)
		mov	#1000, SP		//
		sob	R0, 1$			//
						//
//________________________________________________________________
//
// Инициализация
//
tests:		call	SetLnt			//
		mov	#100, @#177660		// разрешили прерывания от клавиатуры
		mov	#distrp,@#34		// подключили диспетчер вызовов TRAP
		mfps	@#36			//
		trap	0			//
		trap	40			//
        MOV        #TTL,R3
        TRAP    20
        CALL    DETECT
        TST        VALUE1
        BEQ        MEMTS1    ;если после детекта найден контроллер альтпро
        BMI        MEMTS1    ;если прошивка не правильная, тоже тесты проведём, но мы прежупреждали.
        JMP        STOPT    ;иначе тестов памяти делать не будем.
//________________________________________________________________
//
// Тесты памяти
//
MEMTS1:		mov	#TZPREP,R3		// "Подготовка"
		trap	20			//
//
// Этап 1 - пробуем все 32 кода страниц независимо от кол-ва памяти, 
// для каждой страницы заполняем массив PGEERR
//
		clr	R5			//
		mov	#TRST11,@#4		//
		mov	#123456, R4		//
		br	0TR3			//
0TR2:		tst	(R5)+			//
0TR3:		clr	PGEERR(R5)		//
		mov	@#502, R2		// адрес начала ОЗУ 10 или 11М
		mov	RAMCOD(R5), R1		// берем очередной код
		beq	MEMTS2			//
		mov	#'., R0			// выводим точку
		trap	16			// putch
		mov	R1, R0			//
		trap	2			// устанавливаем нужную страницу
		mov	R0, R1			// сохраним исправленный код
						// не подключали ли мы эту страницу ранее?
		mov	#1, R3			// это признак, когда случился halt, 1 - не было чтения
		mov	R2, R0			//
						// проверим, а не подключали ли ранее
		cmp	(R0)+, R4		// если нет чтения, тут будет halt
		beq	1$			//
		nop				// halt по чтению перебросит сюда
		inc	R3			// 2 - не было записи, 
		mov	R4, (R2)+		// если нет записи, тут будет halt
		br	2$			//
		nop				//
		br	0TR2			// <- halt по записи сюда
2$:		mov	#17777, R0		//
3$:		mov	R1, (R2)+		// тут будет halt
		sob	R0, 3$			//
		br      4$			//
		br      0TR2			// <- halt по записи сюда
//
// сюда попадаем если не было halta ни при чтении, ни при записи во всей странице
//
4$:		mov	R4, R2		// проведём байт тест
		mov	R2, (R2)        // допустим, произошёл halt --+
		nop			//
		br	8$		//
		br	9$		// < - сюда
8$:        MOVB    R2,1(R2)    ;допустим, произошёл halt --+
        NOP                    ;                            |
        BR        10$            ;                            |
        BR        9$            ;< - сюда ------------------+

10$:    CMP        #27056,(R2)    ;а здесь halt перейдёт туда ------------+
        BEQ        0TR2    ;байт тест удачно пройден                    |
        NOP            ;байт тест провален                                |
9$:        BIS        #10,PGEERR(R5) ;признак ошибки байт теста < - сюда -+
        BR        0TR2

1$:        BIS        #100000,PGEERR(R5)    ;признак, что страницу уже подключали
        BR        0TR2
;этап2
;2. подсчитываем доступное кол-во ОЗУ
;    для каждой модели имеется набор ожидаемых кодов страниц.
;    выводим на экран ошибки только из этого набора
TRST21:    BIT        (SP)+,(SP)+
        CLR        R1
        BR        1HLT
MEMTS2:    CLR        VALUE1
        MOV        #TRST21,@#4
        MOV        #TZDOZU,R3
        TRAP    20
        CLR        R5
        CLR        R1

1NEXT:		mov	RAMCOD(R5),R0		// берем очередной код
		beq	0END			// если коды кончились - выход
		trap	22			// выведем кол-во озу (десятичное число из R1)
		mov	#40, R0			// выводим пробел
		trap	16			// putch
		mov	PGEERR(R5), R4		// проблемы с этой страницей были
		bpl	1$			//

        ;эту страницу уже подключали
        MOV        R1,-(SP)
        MOV        RAMCOD(R5),R0
        TRAP    2
        MOV        R0,R1
		mov	#TZ2US1, R3		//
		trap	20			// "стр. с кодом "
		trap	24			//
		mov	#TZ2US2, R3		//
		trap	20			// " уже подключали с "
		mov	@#502, R1		//
		mov	2(R1), R1		// код страницы, с которой уже подключали.
1HLT:		trap	24			// 4 воcьмеричных цифры из R1
		mov	(SP)+, R1		//
		br	0NEXT			//
						//
1$:		bit	#1, R4			//
		beq	2$			//
		mov	#TZ3RD,R3		//не было чтения
		trap	20			// "read-"
		mov	#TZ3HL,R3		//
		trap	20			// "halt "
						//
2$:		bit	#2, R4			//
		beq	7$			//
		mov	#TZ3WR, R3		// не было записи
		trap	20			// "write-"
		mov	#TZ3HL, R3		//
		trap	20			// "halt "
						//
7$:		bit	#10, R4			//
		beq	0NEXT			//
		mov	#TZ3BY, R3		// не пройден байт-тест
		trap	20			// "byte-test fail"

0NEXT:    MOV        #TZ2ERC,R3
        TST        R4
        BNE        5$        ;какие-либо ошибки чтения-записи были?
        MOV        #6,R2    ;нет - курсор просто влево.
        TRAP    14
        BR        6$
5$:        TRAP    20        ;вывели ещё сообщение об ошибке, значит делаем перевод строки
        BMI        4$        ;если уже подключали, то не считается
6$:        ADD        #16.,R1    ;увеличим счетчик кб
4$:        TST        (R5)+    ;перемещаемся дальше по таблице
        CMP        R5,TZCN    ;для заданной модели контроллера таблица кончилась?
        BLO        1NEXT    ;если нет - продолжим
0END:    TRAP    22        ;выведем конечное кол-во озу

        CALL    TSTHDD
        CALL    TSTHDR
        CALL    TSTRST
        CALL    TSTBT2
        CALL    TSTBT3

;тест режимов
TREZ:    CALL    MEMTS4    ;заполняем память синхрокодом
        MOV        #7,ZN
        TRAP    40
        MOV        #TRZINF,R3
        TRAP    20
        CLR        ERCOD
        CMPB    @#167777,#374
        BLO        1$    ;если А16, то не проверять HDD ОЗУ
        CMPB    @#167776,#300
        BHIS    1$
        MOV        #240,SMKCON ;для контроллеров SMK там NOP
1$:        MOV        #REZ,R5
        MOV        TZCODS,R4
        MOV        #SYNCW,R2
        MOV        #AH,@#4
        MOV        #277,-(SP)    ;8 реж. * 8 банков

Z1:        MOV        @#500,R0
        BPL        10$
        TRAP    4            ;для БК11М, надо включать стандартный режим,
        MOV        #100000,R1    ;чтобы
        MOV        #20000,R0    ;чистить верхнее ОЗУ, чтобы гарантированно отличить его от 
12$:    CLR        (R1)+        ;ДОЗУ
        SOB        R0,12$        ;это нужно делать каждый раз при смене режима
10$:    MOVB    (R5),R1        ;выводим код режима.
        TRAP    24
        MOV        #':,R0
        TRAP    16
        CLR        VALUE1
        MOV        #100172,R3    ;начальный адрес для проверки
Z2:        MOV        R3,TZADDR
        MOV        #1003,ZC    ;BNE 3$ = норм.!!!
        MOVB    (R5),R0        ;очередной режим
        BNE        7$            ;привязка к коду режима !!!
        TST        @#500
        BMI        7$            ;если БК11 - не надо никаких привязок
        CMP        R3,#120000
        BHIS    7$            ;ПЗУ мон.БК10 может не откл:
        MOV        #240,ZC        ;ПЗУ есть = нет: != == halt
7$:        MOV        R0,TZMODE    ;режим для вывода на экран
        TRAP    4
        CMP        R3,#177172
        BEQ        2$
        INCB    (SP)
        BEQ        ZE
2$:        CLR        R0            ;тут накапливается код результата теста
        CMP        R2,(R3)        ;тестируем, есть ли доступ по чтению
ZC:        BNE        3$
        BEQ        4$
        CMP        (R0)+,(R0)+    ;<-halt сюда для cmp
4$:        CMP        (R0)+,(R0)+
        ;зесь R0 == 0, 4, 010 при !=, =, halt
3$:        MOV        R3,(R3)        ;тестируем, есть ли доступ по записи
        CMP        R2,(R3)        ;тестируем, работает ли запись как надо
        BEQ        6$            ;если запись прошла, но по чтению всё равно изначальный вариант
        NOP                    ;<-halt сюда для mov
        MOV        R2,(R3)        ;<-halt сюда для cmp
        CMP        R2,(R3)
        BR        5$
        BR        1$            ;<-halt сюда для mov
5$:        BNE        6$            ;<-halt сюда для cmp - !=
        INC        R0            ;write
6$:        INC        R0            ;nowr
1$:        CMP        R0,#11        ;для HALT-ОЗУ: R0=11->10
        BNE        7$            ;-
        CMPB    (SP),#327    ;это у нас сегмент 177000 в режиме 120?
        BNE        7$            ;нет
        DEC        R0            ;да, для старой версии прошивки подменяем код с ОЗУзч на ПУСТО
7$:        CMPB    (SP),#366    ;а это сегмент 160000 в режиме 100?
        BNE        SMKCON        ;нет
        CMP        R0,#4        ;да, а схема старая?
        BNE        SMKCON        ;нет, новая
        TST        (R0)+        ;для старой подменяем код ОЗУзз на ОЗУ
SMKCON:    BR        0$
        CMP        R3,#170172
        BNE        0$
        CMPB    (SP),#307    ;сегмент 177000 для режима 160
        BEQ        0$            ;не проверять
        SUB        #1000,R3    ;вот поэтому то у нас и проверяется 2 раза сегмент 17
        MOV        #6,R1
        BR        3$

0$:        MOVB    (R4)+,R1
3$:        CMPB    R0,R1
        BEQ        2$
        MOVB    R0,TRCODE        ;то, что есть - в мл.байт
        MOVB    R1,TRCODE+1        ;то, что должно быть - в ст.байт
        CALL    TRERR
        INC        VALUE1
        INC        ERCOD
2$:        ADD        #10000,R3
        BMI        Z2
        INC        R5
        TST        VALUE1
        BNE        8$
        MOV        #TROK,R3
        TRAP    20
8$:        TRAP    12
        DEC        (PC)+
ZN:        .WORD    7            ;всего 8 режимов
        BPL        Z1
ZE:        TST        ERCOD
        BEQ        11$
        MOV        #ERINFO,R3
        TRAP    20
11$:
;тест режимов 2
;проведем тесты переключения между режимами (20 и 100) и (20 и 0)
;по типу синхротеста.
TREZ2:    TRAP    40
        CMPB    @#167777,#374
        BLO        0MEMTS    ;если А16, то пропустить тест
        MOV        #TRSWPG,R3
        TRAP    20
        MOV        #TRST31,@#4
        MOV        #SWREZ,R4
0$:        MOV        R4,-(SP)
        CALL    MEMTS4    ;заполняем синхротест
        MOV        (SP)+,R4
        MOVB    (R4)+,R0    ;берём первый режим
        TSTB    (R4)
        BMI        MEMTS3
        MOV        R0,R1
        TRAP    4        ;включаем
        TRAP    24        ;рисуем на экране
        MOV        #"->,R0
        TRAP    16
        SWAB    R0
        TRAP    16
        MOVB    (R4),R0    ;берём режим, на который переключаемся
        MOV        R0,TZMODE
        MOV        R0,R1
        TRAP    4        ;включаем
        TRAP    24        ;рисуем на экране
        TRAP    12
        TST        R1
        BNE        1$
        MOV        #TRSKIP,R3
        TRAP    20
        BR        0$
1$:        MOV        @#502,R2
        MOV        #20000,R5
        CALL    SYNCTS    ;синхротест
        TRAP    12
        BR        0$
;этап3
;3. тестируем на сбойность доступное кол-во ОЗУ
;с подробным выводом каждого сбоя в таком виде:
;код - маска адрес:сбойные биты
MEMTS3:    CALL    MEMTS4
0MEMTS:    MOV        #TZERRS,R3
        TRAP    20
        MOV        #MEMTST,R4
        CALL    MEMSSS
        CALL    MEMTS4
        MOV        #TZEST2,R3
        TRAP    20
        MOV        #MEMTSU,R4
        CALL    MEMSSS
        SOB        R3,.
        SOB        R3,.
        SOB        R3,.
        SOB        R3,.
;проверка контрольной суммы.
CRCCHK:    TRAP    40
        MOV        #4,R4
        MOV        #STOPT,(R4)
        MOV        #CRCINF,R3
        TRAP    20
        TRAP    6
        TRAP    20    ;вывод следующего asciz
        CALL    CRC        ;считаем crc
        MOV        R0,R5    ;и преобразуем его в hex-текст
2$:        MOV        #4,R1
        CLR        R2
1$:        ROL        R0
        ROL        R2
        SOB        R1,1$
        ADD        #101,R2
        MOVB    R2,(R3)+
        SOB        R4,2$
        CMP        -(R3),-(R3)
        TRAP    20    ;и выведем его на экран
3$:        MOV        #12,R4
4$:        CALL    CRC
        CMP        R5,R0
        BNE        5$
        SOB        R4,4$
        TRAP    20
        TST        -(R3)
        BR        3$
5$:        CLR        R0
        CALL    ERRR0
        SOB        R0,.
        BR        3$

;-------подпрограммы-
TRST11:    ;обработка halt для подготовительного этапа
        BIS        R3,PGEERR(R5)
AH:        ;обработка halt для теста режимов
        ADD        #4,(SP)
        RTI

MEMSSS:    MOV        #TRST31,@#4
        CLR        R1
32NEXT:    MOV        RAMCOD(R1),R0    ;берем очередной код
        BEQ        31END            ;если коды кончились - выход
        TST        PGEERR(R1)        ;эту страницу уже подключали
        BMI        31NEXT            ;да - ее не тестируем
        MOV        @#502,R2
        MOV        #20000,R5
        TRAP    2
        MOV        R0,TZMODE        ;сохраняем режим, т.к. для вывода на экран нужно включать стандартный режим
4$:        CALL    KEYPRS            ;если кнопка нажата, то может она ещё с прошлого раза нажата.
        BEQ        4$                ;подождём, пока отпустят.
        CALL    SYNCTS            ;синхротест
        CALL    MEMTSS
31NEXT:    TST        (R1)+            ;перемещаемся дальше по таблице
        CMP        R1,TZCN            ;для заданной модели контроллера таблица кончилась?
        BLO        32NEXT            ;если нет - продолжим
31END:    RETURN

;синхротест
SYNCTS:    CALL    MTINF2
        MOV        R1,-(SP)
        MOV        R5,R1
        MOV        R2,R3
        MOV        #SYNCW,R0        ;синхрокод
        MOV        R0,ERT31
2$:        CALL    KEYPRS
        BEQ        0SKIP
        CLR        VALUE1
        CMP        R0,(R3)
        BEQ        1$
        TST        VALUE1        ;если случился halt
        BNE        1$            ;то не надо, уже вывели сообщение об ощибке
        CALL    EROUT2        ;выведем сообщение, что ошибка синхротеста
1$:        INC        R3
        INC        R3
        SOB        R1,2$
0SKIP:    CALL    KEYPRS            ;если кнопка нажата, то может она ещё с прошлого раза нажата.
        BEQ        0SKIP            ;подождём, пока отпустят.
        MOV        (SP)+,R1
        RETURN
        
;если случился halt при тестировании
TRST31:    CALL    EROUT1
TRST30:    RTI                    ;продолжим тесты, как будто ничего не было

MEMTSS:    MOV        #2,R3
        CLR        R0
1$:        COM        R0    ;-1
        CALL    (R4)
        COM        R0    ;0
        CALL    (R4)
        SOB        R3,1$
        MOV        #16.,R3
        INC        R0    ;1
2$:        CALL    (R4)
        ASL        R0
        SOB        R3,2$
        TST        (R3)+ ;2
3$:        CLR        R0
        CALL    (R4)
        COM        R0    ;-1
        CALL    (R4)
        SOB        R3,3$
        MOV        #16.,R3
        DEC        R0    ;-2
4$:        CALL    (R4)
        SEC
        ROL        R0
        SOB        R3,4$
        TST        (R3)+ ;2, R0 = -1
5$:        CALL    (R4)
        COM        R0
        CALL    (R4)
        COM        R0
        SOB        R3,5$
        MOV        #16.,R3    ;R0 = -1
6$:        CALL    (R4)
        CLC
        ROR        R0
        SOB        R3,6$
        MOV        #16.,R3    ;R0 = 0
7$:        CALL    (R4)
        SEC
        ROR        R0
        SOB        R3,7$
        TST        (R3)+ ;2, R0 = -1
8$:        CALL    (R4)
        COM        R0
        CALL    (R4)
        COM        R0
        SOB        R3,8$
;добавляем длительное тестирование
        TST        @#LNGTST
        BEQ        10$
9$:        MOV        #-1,R0
        CALL    RANDOM
        CALL    (R4)
        SOB        R3,9$
10$:    RETURN

MEMTST:    MOV        R3,-(SP)
        MOV        R4,-(SP)
        TRAP    32
        MOV        R5,R4
        MOV        R2,R3
1$:        CALL    KEYPRS
        BEQ        MSKIP
        CLR        VALUE1
        CLR        ERT31
        MOV        R0,(R3)
        INC        ERT31
        CMP        R0,(R3)
        BEQ        0$
        ;случилась ошибка. надо вывести на экран
        TST        VALUE1
        BNE        0$
        CALL    ERROUT
0$:        INC        R3
        INC        R3
        SOB        R4,1$
        BR        0MOUT

MEMTSU:    MOV        R3,-(SP)
        MOV        R4,-(SP)
        TRAP    32
        MOV        R5,R4
        MOV        R2,R3
        CLR        ERT31
1$:        CALL    KEYPRS
        BEQ        MSKIP
        MOV        R0,(R3)
        INC        R3
        INC        R3
        SOB        R4,1$
        MOV        R5,R4
        MOV        R2,R3
        INC        ERT31
2$:        CALL    KEYPRS
        BEQ        MSKIP
        CLR        VALUE1
        CMP        R0,(R3)
        BEQ        0$
        ;случилась ошибка. надо вывести на экран
        TST        VALUE1
        BNE        0$
        CALL    ERROUT
0$:        INC        R3
        INC        R3
        SOB        R4,2$
0MOUT:    MOV        (SP)+,R4
        MOV        (SP)+,R3
        RETURN
MSKIP:    MOV        (SP)+,R4
        MOV        (SP)+,R3
        TST        (SP)+
        RETURN

ERRR0:    MOV        R3,-(SP)
        MOV        R1,-(SP)
        MOV        R0,-(SP)
        MOV        #TERR,R3
        TRAP    20
        MOV        SP,R3
        TRAP    20
        MOV        (SP)+,R0
        MOV        (SP)+,R1
        MOV        (SP)+,R3
        RETURN

;новый вид вывода сообщений об ошибках
;такого вида Segment-Code(Code) - в скобках то, что должно быть
TRERR:    ;портит R0,R1
        MOV        TZADDR,R1    ;адрес, из которого получаем номер сегмента по 10000 байт
        SWAB    R1
        ASR        R1
        ASR        R1
        ASR        R1
        ASR        R1
        BIC        #177760,R1    ;сегмент
        MOV        #26440,R0
        TRAP    16
        TRAP    10
        SWAB    R0
        TRAP    16
        MOV        TRCODE,R1    ;код, то что есть
        MOV        R1,-(SP)
        CLRB    (SP)        ;ст.байт - то, что должно быть
        BIC        (SP),R1        ;мл байт - то, что есть
        TRAP    10
        MOV        #"(),R0
        TRAP    16
        MOV        (SP)+,R1    ;код, то что должно быть
        SWAB    R1
        TRAP    10
        SWAB    R0
        TRAP    16
        RETURN

;подготовительный этап перед 3м этапом
;идея в том, чтобы заполнить все страницы памяти определённым кодом,
;чтобы отловить ошибку следующего вида: пишем в одну ячейку памяти,
;а меняются данные в какой-то другой ячейке в другой странице.
MEMTS4:    CLR        R5
        MOV        #SYNCW,R4
        MOV        #TRST30,@#4
11$:    MOV        @#502,R2
        MOV        RAMCOD(R5),R0    ;берем очередной код
        BEQ        10$
        TST        PGEERR(R5)    ;если на странице были ошибки
        BNE        12$            ;то её пропустим
        TRAP    2            ;устанавливаем нужную страницу
        MOV        #20000,R1
13$:    MOV        R4,(R2)+
        SOB        R1,13$
12$:    TST        (R5)+
        CMP        R5,TZCN
        BLO        11$
10$:    RETURN

MTMIN2:    TRAP    24        ;выведем код страницы, текущего режима
        MOV        #" -,R0
        TRAP    16
        SWAB    R0
        TRAP    16
        SWAB    R0
        TRAP    16
        MOV        R5,R1
        TRAP    30        ;выведем маску
        RETURN

MTMIN3:    TRAP    24        ;выведем код страницы, текущего режима
        MOV        #TZSYN1,R3
        TRAP    20
        RETURN

;вывод инфы о текущем режиме тестирования
MTINFO:    JSR        R5,PUSHA
        MOV        R0,R5
        MOV        TZMODE,R1
        TRAP    34
        BR        EROUE3

;вывод инфы о синхропоследовательности
MTINF2:    JSR        R5,PUSHA
        MOV        TZMODE,R1
        TRAP    36
EROUE3:    MOV        #15,R0
        TRAP    16
        BR        EROUE2
;вывод сообщения от ошибке синхропоследовательности
;на входе
;r3 - адрес, где случилась ошибка
EROUT2:    JSR        R5,PUSHA
        MOV        TZMODE,R1
        MOV        R3,-(SP)     ;адрес с ошибкой
        TRAP    36
        MOV        (SP),R1        ;выведем адрес, где случилась ошибка
        TRAP    26
        MOV        #':,R0
        TRAP    16
        MOV        @(SP)+,R1    ;выведем неправильное значение
        TRAP    26
        MOV        #TZSYNF,R3
        TRAP    20
        BR        EROUEN
;на входе
;r0 - маска, с которой случилась ошибка
;r3 - адрес, где случилась ошибка
ERROUT:    JSR        R5,PUSHA
        MOV        R0,R5    ;что должно быть
        MOV        TZMODE,R1
        MOV        (R3),-(SP)    ;что есть
        MOV        R3,-(SP) ;адрес с ошибкой
        TRAP    34
        MOV        #" :,R0
        TRAP    16            ;выведем ' '
        MOV        (SP)+,R1    ;выведем адрес, где случилась ошибка
        TRAP    26
        SWAB    R0
        TRAP    16            ;выведем ':'
        MOV        (SP)+,R1
        TRAP    30            ;выведем то, что прочлось
        BR        EROUEN

;обработка ошибки по halt.
;r3 - адрес, где случилась ошибка
EROUT1:    INC        VALUE1    ;признак halt 
        JSR        R5,PUSHA
        MOV        R0,R5    ;что должно быть
        MOV        TZMODE,R1
2$:        MOV        R3,-(SP) ;адрес с ошибкой
        TRAP    34
        MOV        #" :,R0
        TRAP    16            ;выведем ' '
        MOV        (SP)+,R1    ;выведем адрес, где случилась ошибка
        TRAP    26
        SWAB    R0
        TRAP    16            ;выведем ':'
        MOV        #TZ3WR,R3		// "write-"
        TST        ERT31
        BEQ        0$
        MOV        #TZ3RD,R3		// "read-"
0$:        TRAP    20
        MOV        #TZ3HL,R3
        TRAP    20
EROUEN:    MOV        #12,R0
        TRAP    16            ;перевод строки
EROUE2:    RETURN

SETPGE:    TST        @#500    ;БК11?
        BPL        VKL        ;нет
        BIC        #40,R0    ;да


VKL:    MOV        R0,CURMOD
VKL0:    MOV        @#4,VV4BUF
        MOV        #TRST30,@#4    ;прер по вектору 4 просто будем игнорировать.
        MOV        R0,@#177716
        MOV        #6,@#177130
        MOV        R0,@#177130
        MOV        #0,@#177130
        CLR        @#177716
        MOV        VV4BUF,@#4
        RETURN
VV4BUF:    .WORD    0    ;буфер сохранения вектора 4
CURMOD:    .WORD    0

trp_vklstd:	mov	R0,-(SP)
		mov	@#500, R0
		trap	4
		mov	(SP)+,R0
		return

;выход из теста CRC по кнопке стоп
STOPT:    MOV        @#506,@#4
        MOV        #1000,SP
        TRAP    40
        MOV        #ENDTST,R3
        TRAP    20
        TRAP    6        ;ждём нажатия клавини
                        ;выходим
        HALT

ZAGR:    CALL    @#150170    ;БК11М - выход в клавиатурный монитор
        EMT        0
        EMT        1
        HALT

//________________________________________________________________
//
trp_init:    MOV        #500,R1
        MOV        (R1)+,R0
        BPL        2$
        MOV        #100000,(R1)+    ;адр.нач.ОЗУ - 11M
        TST        (R1)+    ;SCR.INIT
        MOV        #ZAGR,(R1)        ;для вых.в MON
        MOV        #16000,@#114    ;как в ANDOS
        BR        1$

2$:        MOV        #120000,(R1)+    ;10
        TST        (R1)+
        MOV        #100274,(R1)
1$:        TRAP    4
        CALL    SCRINI
        RETURN

//________________________________________________________________
//
EMT6:    CALL    KEYPRS
        BNE        EMT6
        MOVB    @#177662,R0
        RETURN
KEYPRS:    BIT        #100,@#177716
        RETURN

//________________________________________________________________
//
// Вывод строки по адресу R3, использует R0
//
trp_jirn:	mov	R2, -(SP)		//
		mov	R5, -(SP)		//
3$:		movb	(R3)+, R0		// используем R0
		beq	1$			//
		cmpb	R0, #220		// 200-220 - повтор 1-20,64 раз
		bgt	4$			//
		blt	6$			//
		movb	#277, R0		// полная строка
6$:		movb	R0, R2			//
		clr	-(SP)			//
		movb	(R3)+, (SP)		//
		mov	R3, R5			//
5$:		mov	SP, R3			//
		call	trp_jirn		//
		decb	R2			//
		bmi	5$			//
		mov	R5, R3			//
		tst	(SP)+			//
		br	3$			//
4$:		call	trp_putch		// вывод очередного символа R0
		br	3$			//
						//
1$:		mov	(SP)+, R5		// возврат
		mov	(SP)+, R2		//
		return				//
//________________________________________________________________
//

;двигаем курсор на заданное количество раз влево,
;R2 - количество раз
CURLT:    MOV        #10,R0
7$:        TRAP    16
        SOB        R2,7$
        RETURN

TTIM:    MOV        R2,2(R5)    ;тест таймера
        MOV        R2,R0
        CALL    (R2)
        MOV        (R5),R0
        RETURN

CRC:    MOV        #160000,R1
        MOV        #4000,R2
        CLR        R0
0$:        ADD        (R1)+,R0
        ADC        R0
        SOB        R2,0$
        RETURN

;вывод в бинарном виде
;вход - R1 число
BINOUT:    JSR        R5,PUSHA
        MOV        #16.,R2
0$:        MOV        #30,R0
        ASL        R1
        ROL        R0
        TRAP    16
        SOB        R2,0$
        RETURN

;вывод числа из R1, без подавления ведущих нулей
D6OUT3:    JSR        R5,PUSHA
        MOV     #6,R4    ;максимальное кол-во цифр в числе
        BR        DGOUT$
//________________________________________________________________
//
// вывод 4-х значного числа из R1, без подавления ведущих нулей
//
trp_d4out3:	jsr	R5,PUSHA
        MOV     #4,R4    ;максимальное кол-во цифр в числе
DGOUT$:    MOV        R4,R5    ;счетчик цифр
0$:        MOV     R1,R0
        BIC     #177770,R0    ;получим очередную цифру
        ADD     #'0,R0
        MOV     R0,-(SP)    ;в стек ее
        ROR     R1        ;пододвинем следующую, ADD бит С обнуляет, так что можно
        ASR     R1
        ASR     R1        ;цифры остались?
        SOB     R4,0$
1$:        MOV     (SP)+,R0
        TRAP    16
        SOB     R5,1$
        RETURN
//________________________________________________________________
//
// вывод десятичного числа из R1 с подавлением ведущих нулей
//
trp_decout:	JSR        R5,PUSHA
        CLR        R5
        MOV        #CONST,R2
6$:        CLR        R0
        MOV        (R2)+,R4
        BEQ        2$
1$:        SUB        R4,R1
        BCS        0$
        INC        R0
        BR        1$
0$:        ADD        R4,R1
        BIS        R0,R5
        BNE        4$
        CMP        #1,R4
        BEQ        4$
        MOV        #-20,R0    ;вместо ведущих нулей будем рисовать пробелы.
4$:        ADD        #'0,R0
        TRAP    16
        BR        6$
2$:        RETURN

;вывод числа из R1, с подавлением ведущих нулей
DGOUT:    JSR        R5,PUSHA
        MOV     #6,R4    ;максимальное кол-во цифр в числе
        CLR        R5        ;счетчик цифр
0$:        MOV     R1,R0
        BIC     #177770,R0    ;получим очередную цифру
        ADD     #'0,R0
        MOV     R0,-(SP)    ;в стек ее
        INC        R5
        ROR     R1        ;пододвинем следующую, ADD бит С обнуляет, так что можно
        ASR     R1
        ASR     R1        ;цифры остались?
        BEQ        1$        ;кончились - выход, если число отрицательное, то мы отработает все 6 цифр.
        SOB     R4,0$
1$:        MOV     (SP)+,R0
        TRAP    16
        SOB     R5,1$
        RETURN

//________________________________________________________________
//
// Диспетчер исключения trap, сохранение регистров обеспечивается
// подпрограммами
//
distrp:		mov	(SP), -(SP)		// скопировали адрес возврата в стек
		sub	#2, (SP)		// получим указатель на инструкцию trap
		mov	@(SP)+, -(SP)		// скопируем инструкцию trap
		bic	#177401, (SP)		// номера функций только чётные, экономим 1 слово
		add	#trptbl, (SP)		//
		mov	@(SP)+, -(SP)		//
		call	@(SP)+			//
		rti				//
						//
trptbl:		.word	trp_init		// 0
		.word	SETPGE			// 2
		.word	VKL			// 4
        .WORD    EMT6    ;6
        .WORD    DGOUT    ;10
        .WORD    OUTCR    ;12
        .WORD    CURLT    ;14
		.word	trp_putch		// 16 - вывод символа из R0
		.word	trp_jirn		// 20 - вывод строки по адресу в R3
		.word	trp_decout		// 22 - вывод десятичного числа из R1 с подавлением ведущих нулей
		.word	trp_d4out3		// 24 - вывод 4 восьмеричных цифр из R1 без подавления нулей
        .WORD    D6OUT3    ;26
        .WORD    BINOUT    ;30
        .WORD    MTINFO    ;32
        .WORD    MTMIN2    ;34
        .WORD    MTMIN3    ;36
		.word	trp_vklstd		// 40

;вызов так: jsr r5,pusha, сохраняем все регистры
;но в r5 нельзя передать параметр, чтобы было можно, есть более сложный метод
PUSHA:    MOV        R4,-(SP)
        MOV        R3,-(SP)
        MOV        R2,-(SP)
        MOV        R1,-(SP)
        MOV        R0,-(SP)
        ;MOV    R5,-(SP) ;это - чтобы и в r5 можно было
        ;MOV    14(SP),R5    ;передавать параметры
        ;CALL    @(SP)+
        CALL    (R5)
        MOV        (SP)+,R0
        MOV        (SP)+,R1
        MOV        (SP)+,R2
        MOV        (SP)+,R3
        MOV        (SP)+,R4
        MOV        (SP)+,R5
        RETURN

;собственный знакогенератор
;инициализация экрана
SCRINI:    MOV        #40000,R1
        MOV        R1,R0
        MOV        R1,@#SCRCRD
        CLR        @#SCRY    ;Y координата, для рулонного сдвига
        CLR        @#SCRLNC ;счётчик строк
        MOV        #1330,@#177664
1:        CLRB    (R1)+
        SOB        R0,1
        MOV        #FONT8,R0
        SUB        #OFSF8,R0
        MOV        R0,@#SCRFNT
        RETURN

OUTCR:    MOV        #12,R0
trp_putch:	jsr	R5, PUSHA
        CALL    VKLSTP
        BIC        #177400,R0
        BITB    #140,R0
        BNE        01
        ;обрабатываем спецсимволы
        MOV        @#SCRCRD,R3
        CMP        #15,R0
        BNE        23
        BIC        #77,R3
        BR        31
23:        CMP        #12,R0
        BNE        21
        BIC        #77,R3
        BR        22
21:        CMP        #10,R0
        BNE        20
        BIT        #77,R3
        BEQ        20
        DEC        @#SCRCRD
        BR        20
01:        TSTB    R0
        BPL        02
        SUB        #40,R0
02:        ASL        R0
        ;MOV    R0,R2
        ASL        R0
        ASL        R0
        ;ADD    R2,R0
        ADD        @#SCRFNT,R0
        MOV        #10,R2
        MOV        @#SCRCRD,R1
        MOV        R1,R3
03:        MOVB    (R0)+,(R1)
        ADD    #100,R1
        BPL        04
        SUB        #40000,R1
04:        SOB        R2,03
        ;двигаем адрес вывода
05:        MOV        R3,R1
        MOV        #177700,R0
        BIC        R0,R1
        COM        R0
        CMP        R1,R0    ;дошли до конца строки?
        BHIS    10        ;да, надо делать перевод строки
        INC        @#SCRCRD ;нет, просто на следующую позицию вправо
        BR        20
10:        BIC        R0,R3
22:        INC        @#SCRLNC
        ADD        #1000,R3    ;высота символов 8 точек
        BPL        11
        SUB        #40000,R3    ;это новая координата
11:        MOV        R3,R2        ;если делать рулонный сдвиг, то прежде надо будет очистить от старого текста
        CMP        @#SCRY,#37    ;Если мы в самом низу
        BHIS    13            ;то увеличивать координату больше не надо
        INC        @#SCRY        ;иначе увеличим
        BR        31
13:        ;делаем рулонный сдвиг
        MOV        @#177664,R0
        BIC        #177400,R0
        MOV        #10,R1        ;высота символов 8 точек
15:        MOV        #40,R4
14:        CLR        (R2)+
        SOB        R4,14
        TST        R2
        BPL        16
        SUB        #40000,R2
16:        INCB    R0
        BIS        #1000,R0
        MOV        R0,@#177664
        SOB        R1,15
31:        MOV        R3,@#SCRCRD
        CMP        @#SCRLNC,#37
        BLT        20
        MOV        #-1,@#SCRLNC
        MOV        #PRANYK,R3
        CALL    trp_jirn
32:        CALL    KEYPRS
        BNE        32
        TST        @#177662
33:        CALL    KEYPRS
        BEQ        33
        CALL    OUTCR
20:
RETVKL:    MOV        R0,-(SP)
        MOV        CURMOD,R0
        BR        00VKL
VKLSTP:    MOV        R0,-(SP)
        MOV        @#500,R0
00VKL:    CALL    VKL0
        MOV        (SP)+,R0
        RETURN

;rnd генератор.
;вход: R0 - макс.значение
;выход: R0 - результат
RANDOM:    MOV        R1,-(SP)
        MOV        R2,-(SP)
        CALL    FRN
        MOV        R0,R1
        CLR        R2
        MOV        RAN,R0
        SEC
3A:        BIC        R2,R0
        ROR        R2
        CMP        R0,R1
        BHI        3A
        MOV        (SP)+,R2
        MOV        (SP)+,R1
        RETURN
FRN:    SWAB    (PC)+
RAN:    .WORD    0
        INCB    RAN
        ROLB    RAN+1
MM:        ADD        #0,RAN
        ADD        #3337,MM+2
        RETURN


DETECT:    TST        @#500        ;чтобы тест нельзя было запустить
        BPL        20$            ;повторно
        MOV        #140000,R0    ;сделаем переход на 
        BR        21$            ;выход в монитор
20$:    MOV        #100000,R0    ;потому что, этот кусок кода используется только один раз в начале
21$:    MOV        #137,@#1000    ;а затем затирается оперативными данными
        MOV        R0,@#1002
        ;определяем тип контроллера и кол-во памяти по значению в 167776
        CLR        VALUE1    ;флаг, что не найден контроллер альтпро
        CLR        SMKHDD
        MOV        @#167776,R5    ;в мл. байте версия прошивки
        MOV        R5,R0
        CLRB    R0
        BIC        R0,R5
        SWAB    R0            ;в мл байте код количества памяти
        CMPB    R0,#370
        BLO        0$
        MOV        #CODES,R3
        CLR        R4
2$:        TSTB    (R3)
        BEQ        0$
        CMPB    R0,(R3)+
        BEQ        1$
        INC        R4
        BR        2$

0$:        MOV        #NOALTP,R3
        TRAP    20
        INC        VALUE1
        RETURN

1$:        ;нашли
        MOV        #4,R3
        CMP        R4,R3    ;для а16 нечего делать
        BLO        3$        ;а если smk или a64m, надо определить, что это
        CMPB    R5,#300
        BHIS    3$
        COM        SMKHDD
        ADD        R3,R4
3$:        ASL        R4
        MOV        #FOUND,R3
        TRAP    20
        MOV        TZCTB(R4),TZCN
        MOV        NMTBL(R4),R3
        TRAP    20    ;выведем имя контроллера
        MOV        #VERS,R3
        TRAP    20    ;выведем версию, в нечеловекообразном виде
        MOV        R5,R1
        TRAP    10
        TRAP    12        ;вывели всё. теперь надо переходить к тестам
        ;теперь проверим какая прошивка, будем просто использовать кусок теста режимов.
        CMP        R4,#10    ;если это не СМК
        BLO        15$        ;то прошивку проверять не надо
        TST        @#500
        BPL        17$
        MOV        #CODS11,TZCODS
        BR        18$
17$:    MOV        #CODS,TZCODS
18$:    MOV        #AH,@#4
        MOV        #100,R0        ;код режима
        MOV        #SYNCW,R2    ;проверочное слово
        MOV        #160172,R3    ;адрес для проверки
        CLR        R5
        CALL    DTOLD
        CMP        #4,R0
        BNE        10$
        INC        R5
10$:    MOV        #120,R0
        MOV        #177172,R3
        CALL    DTOLD
        CMP        #11,R0
        BNE        11$
        INC        R5
11$:    MOV        #VERRT,R3
        TRAP    20
        TST        R5
        BNE        12$
        MOV        #RTOK,R3
        BR        14$
12$:    COM        VALUE1        ;отметим, что прошивка неправильная
        CMP        #2,R5
        BNE        13$
        MOV        #RTBAD,R3
        BR        14$
13$:    MOV        #RTERR,R3
14$:    TRAP    20
        RETURN
15$:    TST        @#500
        BPL        16$
        MOV        #CODA11,TZCODS
        RETURN
16$:    MOV        #CODA,TZCODS
        RETURN

DTOLD:    MOV        R0,-(SP)
        MOV        #20,R0        ;включаем режим 20, чтобы вписать куда нужно проверочное слово
        TRAP    4            ;чтобы алгоритм из теста режимов срабатывал стандартно
        MOV        R2,-40000(R3)
        MOV        (SP)+,R0
        TRAP    4            ;устанавливаем нужный режим
        CLR        R0            ;тут накапливается код результата теста
        CMP        R2,(R3)        ;тестируем, есть ли доступ по чтению
        BNE        3$
        BEQ        4$
        CMP        (R0)+,(R0)+    ;<-halt сюда для cmp
4$:        CMP        (R0)+,(R0)+
        ;зесь R0 == 0, 4, 010 при !=, =, halt
3$:        MOV        R3,(R3)        ;тестируем, есть ли доступ по записи
        CMP        R2,(R3)        ;тестируем, работает ли запись как надо
        BEQ        6$            ;если запись прошла, но по чтению всё равно изначальный вариант
        NOP                    ;<-halt сюда для mov
        MOV        R2,(R3)        ;<-halt сюда для cmp
        CMP        R2,(R3)
        BR        5$
        BR        1$            ;<-halt сюда для mov
5$:        BNE        6$            ;<-halt сюда для cmp - !=
        INC        R0            ;write
6$:        INC        R0            ;nowr
1$:        RETURN

TSTHDD:    TRAP    40
        MOV        #THINFO,R3
        TRAP    20
        TST        SMKHDD
        BNE        0OK
        MOV        #THERR,R3
        TRAP    20
        RETURN

0OK:    MOV        #AH,@#4
        MOV        #REGHDD,R5
        MOV        #377,R4
03$:    MOV        (R5)+,R1
        BEQ        0EX
        TRAP    10
        MOV        #": ,R0
        TRAP    16
        SWAB    R0
        TRAP    16
        MOV        #THRESL,R3
        MOV        R4,(R1)
        BR        00$
        NOP
        BR        01$
00$:    CMP        (R1),R4
        BR        02$
        NOP
        BR        01$
02$:    TST        (R3)+
01$:    TRAP    20
        BR        03$
0EX:    RETURN
REGHDD:    .WORD 177740,177742,177744,177746,177750,177752,177754,177756,177741,177743,0

;тест ОЗУ, выделенного под буфер HDD
TSTHDR:    TRAP    40
        MOV        #THINF2,R3
        TRAP    20
        TST        SMKHDD
        BNE        0OK
        MOV        #THERR,R3
        TRAP    20
        RETURN
;подготовим контрольный массив
0OK:    MOV        #30000,R5
        MOV        #3400,R4
        MOV        R5,R1
        MOV        R4,R2
        MOV        #123456,R0
        MOV        #65432,R3
2:        MOV        R0,(R1)+
        XOR        R0,R3
        ROL        R3
        ROR        R0
        ADC        R3
        BCC        1
        SWAB    R0
1:        ROL        R3
        ROR        R0
        ADC        R3
        BCC        0
        SWAB    R3
0:        ADD        R3,R0
        SOB        R2,2
;посчитаем его CRC
;и заодно скопируем в буфер ОЗУ HDD
        MOV        #TH4TR,@#4
        MOV        R5,R1
        MOV        R4,R2
        MOV        #170000,R3
        CLR        R0
0$:        MOV        (R1),(R3)+
        ADD        (R1)+,R0
        ADC        R0
        SOB        R2,0$
        MOV        R0,R5
        MOV        #160,R0
        TRAP    4
        SOB        R2,.
        TRAP    40
        MOV        #170000,R1
        MOV        R4,R2
        CLR        R0
1$:        ADD        (R1)+,R0
        ADC        R0
        SOB        R2,1$
        MOV        #THROK,R3
        CMP        R0,R5
        BEQ        2$
        MOV        #THRER,R3
        BR        2$
TH4TR:    BIT        (SP)+,(SP)+
        MOV        #THRERN,R3
2$:        TRAP    20
        RETURN

TSTRST:    ;тест влияния ресета
        MOV        #TRINFO,R3
        TRAP    20
;1. Заполним каждую страницу своим уникальным кодом.
        CALL    MEMFIL    ;ну, почти всю страницу, одного слова в одном месте достаточно
;2. Включаем стандартный режим
        TST        @#500
        BMI        011
        MOV        #120,R0
        TRAP    4
        BR        010

011:    MOV        #140,R0
        TRAP    4
        MOV        #16000,@#177716
        MOV        #100000,R1
        MOV        #20000,R0
10$:    CLR        (R1)+
        SOB        R0,10$
010:
;3. Запоминаем, что было
        CALL    RDCRD
;4. Делаем ресет
        RESET
;5. Смотрим, что стало
        CALL    RDRES
;Вывод результатов
        MOV        #ADDRSS,R5
        MOV        #DTAB,R4
12$:    MOV        (R5)+,R1
        BEQ        11$
        MOV        #TADDR,R3
        TRAP    20
        TRAP    26
        CMP        DTAA-DTAB(R4),(R4)+
        BNE        13$
        CMP        DTAA-DTAB(R4),(R4)+
        BNE        14$
        MOV        #TANRM,R3
        TRAP    20
        BR        12$
14$:    MOV        -2(R4),R1
        BR        15$
13$:    MOV        (R4),R1
15$:    MOV        #TAERR,R3
        TRAP    20
        TRAP    10
        MOV        #12,R0
        TRAP    16
        BR        12$
11$:    MOV        #TRRSOK,R3
        TST        VALUE1
        BEQ        16$
        MOV        #TRRSER,R3
16$:    TRAP    20
        MOV        #TRRSTL,R3
        TRAP    20
        RETURN

RDRES:    MOV        #DTAA,R2
        BR        0RD
RDCRD:    MOV        #DTAB,R2
0RD:    MOV        #ADDRSS,R1
1:        MOV        (R1)+,R0
        BEQ        0
        MOV        (R0)+,(R2)+
        MOV        (R0)+,(R2)+
        BR        1
0:        RETURN

ADDRSS:    .WORD    100000,120000,140000,160000,0

MEMFIL:    CLR        R5
        MOV        #SYNCW,R4
        MOV        #TRST30,@#4
11$:    MOV        @#502,R2
        MOV        RAMCOD(R5),R0    ;берем очередной код
        BEQ        10$
        TST        PGEERR(R5)    ;если на странице были ошибки
        BNE        12$            ;то её пропустим
        TRAP    2            ;устанавливаем нужную страницу
        MOV        #123456,(R2)+
        MOV        R0,(R2)+
        MOV        #17776,R1
13$:    MOV        R4,(R2)+
        SOB        R1,13$
12$:    TST        (R5)+
        CMP        R5,TZCN
        BLO        11$
10$:    RETURN

;тест влияния бита 2
;код 4 блокирует регистры по чтению.
TSTBT2:    MOV        #T2INFO,R3
        TRAP    20
        MOV        #TR4T2,@#4
        MOV        #REZ,R5
1$:        MOVB    (R5)+,R0    ;проверим во всех режимах
        BMI        0$
        TRAP    4
        MOV        #4,@#177130 ;блокируем регистры по чтению
        CLR        VALUE1
        TST        @#177130
        TST        @#177132
        BR        1$

0$:        MOV        #T21,R5
        TST        VALUE1    ;блокируется?
        BEQ        03        ;нет
        MOV        #T2OK,R3    ;да, скажем что ОК
        TRAP    20
        MOV        R5,R3        ;регистры
        TRAP    20
        MOV        #T23,R3    ;блокируются
        TRAP    20
        RETURN
03:        MOV        #T2ERR,R3    ;нет, скажем что ошибка
        TRAP    20
        MOV        R5,R3        ;регистры
        TRAP    20
        MOV        #T22,R3    ;должны блокироваться
        TRAP    20
        RETURN

TR4T2:    INC        VALUE1
        RTI

TSTBT3:    MOV        #T3INFO,R3
        TRAP    20
        TST        @#500
        BPL        0OK
        MOV        #T3NONE,R3
        TRAP    20
        RETURN

0OK:    CALL    MEMFIL
        MOV        #VALUE1,R3
        CLR        (R3)
        MOV        #TR4T2,@#4
        MOV        #SYNCW,R4
        MOV        #120,R0
        TRAP    4
        MOV        #10,@#177130    ;подключаем бейсик, при этом ПЗУ накладывается на ОЗУ,
                                ; и при записи туда должен возникать trap to 4, но не факт.
                                ;ОЗУ может выдать RPLY и ничего не сработает.

        MOV        #120010,R5
        CMP        (R5),R4            ;на случай не срабатывания trap to 4
        BEQ        0$                ;просто провека на контрольное значение
        INC        (R3)
0$:        CLR        (R5)
        ADD        #40000,R5
        CMP        (R5),R4
        BEQ        1$
        INC        (R3)
1$:        CLR        (R5)
        ;теперь второй вариант.
        ;в режиме 140 по адресам 120000-160000 ничего нет.
        ;и если бейсик подключается, там должно работать чтение
        MOV        #AH,@#4
        MOV        #140,R0
        TRAP    4
        MOV        #10,@#177130
        MOV        #120020,R5
        TST        (R5)
        INC        (R3)    ;чтение произошло
        NOP                ;значит бейсик подключается
        ADD        #20000,R5    ;если чтения нет, halt сюда
        TST        (R5)
        INC        (R3)
        NOP
        CMP        TZCN,#C128-RAMCOD
        BLO        01        ;реакция в норме, должно накладываться
        ;не должно.
        TST        VALUE1
        BEQ        02
        MOV        #T2ERR,R3
        BR        05

02:        MOV        #T2OK,R3
        BR        04

01:        TST        VALUE1
        BEQ        03
        MOV        #T2OK,R3
05:        TRAP    20
        MOV        #T31+3,R3
        TRAP    20
        RETURN

03:        MOV        #T2ERR,R3
04:        TRAP    20
        MOV        #T31,R3
        TRAP    20
        RETURN

;-------константы--------------------------
NMTBL:    .WORD    NA16
        .WORD    NA16H
        .WORD    NA16M
        .WORD    NAUNK
        .WORD    NA64M
        .WORD    NA128M
        .WORD    NA256M
        .WORD    NA512M
        .WORD    NS64
        .WORD    NS128
        .WORD    NS256
        .WORD    NS512
CONST:    .WORD    10000.,1000.,100.,10.,1,0
FREQ:    .WORD    2561,2457,2252,177777    ;знач.таймера, последний < 0 !!!
TZCODS:    .WORD    CODS11
;коды ошибок теста режимов для SMK. по 8 байт на режим
CODS:    .BYTE    00,00,06,06,06,06,00,00    ;160
        .BYTE    00,00,06,06,06,06,00,10    ;60
        .BYTE    06,06,06,06,06,06,06,10    ;120
        .BYTE    06,06,06,06,06,06,06,04    ;20
        .BYTE    00,00,10,10,10,10,00,10    ;140
        .BYTE    00,00,10,10,06,06,06,10    ;40
        .BYTE    04,06,06,06,06,06,06,11    ;100
        .BYTE    10,10,10,10,06,06,06,11    ;0

CODS11:    .BYTE    10,10,06,06,06,06,00,00    ;160
        .BYTE    10,10,06,06,06,06,00,10    ;60
        .BYTE    06,06,06,06,06,06,06,10    ;120
        .BYTE    06,06,06,06,06,06,06,04    ;20
        .BYTE    02,02,02,02,00,00,00,10    ;140
        .BYTE    02,02,02,02,06,06,06,10    ;40
        .BYTE    05,06,06,06,06,06,06,11    ;100
        .BYTE    02,02,02,02,06,06,06,11    ;0
;для А16
CODA:    .BYTE    00,00,06,06,06,06,00,00    ;160
        .BYTE    00,00,06,06,06,06,00,10    ;60
        .BYTE    06,06,06,06,10,10,00,10    ;120
        .BYTE    04,06,10,10,10,10,10,10    ;20
        .BYTE    00,00,10,10,10,10,00,10    ;140
        .BYTE    00,00,10,10,06,06,06,10    ;40
        .BYTE    04,06,06,06,10,10,00,10    ;100
        .BYTE    10,10,10,10,06,06,06,11    ;0

CODA11:    .BYTE    10,10,06,06,01,01,00,00    ;160
        .BYTE    10,10,06,06,06,06,00,10    ;60
        .BYTE    06,06,06,06,00,00,00,10    ;120
        .BYTE    04,06,10,10,10,10,10,10    ;20
        .BYTE    02,02,02,02,00,00,00,10    ;140
        .BYTE    02,02,02,02,06,06,06,10    ;40
        .BYTE    05,06,06,06,00,00,00,10    ;100
        .BYTE    02,02,02,02,06,06,06,11    ;0

REZ:    .BYTE    160,60,120,20,140,40,100,0
SWREZ:    .BYTE    120,20,120,100,20,100,0,20,0,377

TZCN:    .WORD C512-RAMCOD
//________________________________________________________________
//
// Коды для подключения страниц памяти
RAMCOD:		.word	160		; 0     (код 0)
C016:		.word	60		;
C032:		.word	2160		;     ;+32Кб (код 2000)
        .WORD 2060
C064:    .WORD 164    ;+64Кб (код 4)
        .WORD 64
        .WORD 2164    ;+96Кб (код 2004)(64+32)
        .WORD 2064
C128:    .WORD 170    ;+128Кб (код 10)
        .WORD 70
        .WORD 2170    ;+160Кб (код 2010)(128+32)
        .WORD 2070
        .WORD 174    ;+192Кб (код 14)(128+64)
        .WORD 74
        .WORD 2174    ;+224Кб (код 2014)(128+64+32)
        .WORD 2074
; это для 512Кб (вторая половина)
C256:    .WORD 161    ;+256Кб (код 1)
        .WORD 61
        .WORD 2161    ;+288Кб (код 2001)(256+32)
        .WORD 2061
        .WORD 165    ;+320Кб (код 5)(256+64)
        .WORD 65
        .WORD 2165    ;+352Кб (код 2005)(256+64+32)
        .WORD 2065
        .WORD 171    ;+384Кб (код 11)(256+128)
        .WORD 71
        .WORD 2171    ;+416Кб (код 2011)(256+128+32)
        .WORD 2071
        .WORD 175    ;+448Кб (код 15)(256+128+64)
        .WORD 75
        .WORD 2175    ;+480Кб (код 2015)(256+128+64+32)
        .WORD 2075
C512:    .WORD 0

TZCTB:    .WORD    C016-RAMCOD
        .WORD    C016-RAMCOD
        .WORD    C016-RAMCOD
        .WORD    C016-RAMCOD
        .WORD    C064-RAMCOD
        .WORD    C128-RAMCOD
        .WORD    C256-RAMCOD
        .WORD    C512-RAMCOD
        .WORD    C064-RAMCOD
        .WORD    C128-RAMCOD
        .WORD    C256-RAMCOD
        .WORD    C512-RAMCOD

;коды в ячейке 167777, определяющие тип контроллера
CODES:    .BYTE    370    ;A16
        .BYTE    371    ;A16+контроллера винта с дозу 4кб
        .BYTE    372    ;A16M
        .BYTE    373    ;не исп-ся
        .BYTE    374    ;SMK64 или A64M
        .BYTE    375    ;SMK128 или A128M
        .BYTE    376    ;SMK256 или A256M
        .BYTE    377    ;SMK512 или A512M
        .BYTE    0
;имена контроллеров
NA16:    .ASCIZ    "A16"
NA16H:    .ASCIZ    "A16HDD"
NA16M:    .ASCIZ    "A16M"
NAUNK:    .ASCIZ    "Несуществующий"
NA64M:    .ASCIZ    "A64M"
NA128M:    .ASCIZ    "A128M"
NA256M:    .ASCIZ    "A256M"
NA512M:    .ASCIZ    "A512M"
NS64:    .ASCIZ    "SMK64"
NS128:    .ASCIZ    "SMK128"
NS256:    .ASCIZ    "SMK256"
NS512:    .ASCIZ    "SMK512"
NOALTP:    .ASCIZ    "Не обнаружен контроллер АльтПро"<12>
FOUND:    .ASCIZ    "Обнаружен контроллер "
VERS:    .ASCIZ    " версия прошивки: "
VERRT:    .ASCIZ    "Версия прошивки 555РТ5: "
RTOK:    .ASCIZ    "новая"<12>
RTBAD:    .ASCII    "старая, не рекомендуется к использованию"
        .ASCII    "из-за неправильных режимов работы, тест будет показывать ошибки"<12>
        .ASCIZ    "синхронизации на БК11М"<12>
RTERR:    .ASCIZ    "повреждена."<12>

TTL:    .ASCII <220>/"/
        .ASCII <210>/ Тест контроллера "АльтПро" с ДОЗУ 64-512 Кб/<12>
        .ASCII <220>/"/
        .ASCIZ <211>" (c) АльтПро 1997, gid 2012, v4.74F"<12>

TERR:    .ASCIZ <7><7>" Error "
TZPREP:		.asciz	"Подготовка"
TZDOZU:    .ASCIZ    <12>"ДОЗУ, Кбайт:"
TZ2ERC:    .ASCIZ    <12><213>" "
TZERRS:    .ASCII    <12>"Тест памяти на ошибки..."
TZEST1:    .ASCIZ    <12>"Этап 1"<12>
TZEST2:    .ASCIZ    <12>"Этап 2"<12>
TZ3WR:		.asciz	"write-"
TZ3RD:		.asciz	"read-"
TZ3HL:    .ASCIZ    "halt "
TZ3BY:		.asciz	"byte-test fail"
TZ2US1:		.asciz	"стр. с кодом "
TZ2US2:		.asciz	" уже подключали с "
TZSYN1:    .ASCIZ    " - синхро           "
TZSYNF:    .ASCIZ    ":ошибка"
TRZINF:    .ASCIZ    <12>"Тест режимов..."<12>
TRSWPG:    .ASCIZ    <12>"Тест переключения страниц..."<12>
TROK:    .ASCIZ    " OK"
TRSKIP:    .ASCIZ    "пропуск."<12>
ERINFO:    .ASCII    "Код ошибки: Сегмент-Код(Код). Сегмент -"<12>
        .ASCII    "сегмент памяти по 10000 байтов, Код - код ошибки, в скобках"<12>
        .ASCII    "ожидаемый код. Расшифровка кодов:"<12>
        .ASCII    "6-ОЗУ, 4-ОЗУзз, 0-ПЗУ, 10-пусто, остальные коды"<12>
        .ASCIZ    "недокументированы: 11-ОЗУзч, 1-ОЗУ на ПЗУ, 2-чужое ОЗУ"<12>

CRCINF:    .ASCII <12><202>"* Для запуска непрерывного теста контрольной суммы ПЗУ"<12>
        .ASCII <203>" нажмите любую клавишу. Правильное значение уточните"<12>
        .ASCIZ <203>" по документации. Прервать тест - СТОП."<12>

        .ASCIZ    <12>"   Код К.С.= "

        .ASCIZ "1234 "

        .ASCIZ "."

TRINFO:    .ASCIZ    <12>"Тест влияния RESET..."<12>
TADDR:    .ASCIZ    "Адрес: "
TANRM:    .ASCIZ    " - без изменений"<12>
TAERR:    .ASCIZ    " - "
TRRSOK:    .ASCIZ    "Норма. RESET не"
TRRSER:    .ASCIZ    "ОШИБКА. RESET"
TRRSTL:    .ASCIZ    " влияет на режимы."<12>
THINFO:    .ASCIZ    <12>"Тест доступности регистров HDD..."<12>
THERR:    .ASCIZ    "Это не СМК, пропускаем тест."<12>
THRESL:    .ASCIZ    "недоступен"<12>
T2INFO:    .ASCIZ    <12>"Тест влияния бита 2..."<12>
THINF2:    .ASCIZ    <12>"Тест буфера ОЗУ HDD..."<12>
THROK:    .ASCIZ    "ОЗУ в норме."<12>
THRER:    .ASCIZ    "Внимание! ОЗУ повредилось!"<12>
THRERN:    .ASCIZ    "Внимание! ОЗУ недоступно!"<12>
T2ERR:    .ASCIZ    "ОШИБКА! "
T2OK:    .ASCIZ    "Норма. "
T21:    .ASCIZ    "Регистры 177130, 177132 "
T22:    .ASCIZ    "должны блокироваться!"<12>
T23:    .ASCIZ    "блокируются."<12>
T3INFO:    .ASCIZ    <12>"Тест влияния бита 3..."<12>
T31:    .ASCIZ    "не подключается ПЗУ Бейсика."<12>
T3NONE:    .ASCIZ    "На БК11(М) бит 3 влияния не имеет."<12>

ENDTST:    .ASCIZ <12><202>"* Тестирование окончено !"
PRANYK:    .ASCIZ    <216>" *** Нажмите любую клавишу. ***"
TZLNTS:    .ASCIZ    "Задайте длительность длинного теста (0 - без теста) ["
        .EVEN

;-------переменные--
TZADDR:    .WORD    0
TZMODE:    .WORD    0
TRCODE:    .WORD    0
VALUE1:    .WORD    0
ERCOD:    .WORD    0
ERT31:    .WORD    0
SMKHDD:    .WORD    0

;тут будут храниться флаги ошибок для каждой страницы
;возможные результаты:
;    0 - всё отлично
;иначе маски:
;    1 - нет записи (halt)
;    2 - Нет чтения (halt)
;    10 - провал байт-теста
;    100000 - страницу уже подключали
PGEERR:    .BLKW    40

DTAB:    .BLKW    10
DTAA:    .BLKW    10

SETLNT:    .ADDR    R1,TZLNTS
        CLR        R2
        EMT        20
        MOV        #32.,R1
        MOV        R1,@#LNGTST
        CALL    DECOU$
        MOV        #"]:,R0
        EMT        16
        SWAB    R0
        EMT        16
        CALL    DECIN        ;ввод десятичного числа
        BCS        1$
        MOV        R1,@#LNGTST
1$:        MOV        #12,R0
        EMT        16
        RETURN

;выход:  R1 - полученное число.
;переполнение не проверяется, так что сколько влезет в 16 бит, столько и будет
;если бит С - то выходной результат недостоверен и должен игнорироваться
DECIN:    CLR        R1        ;счетчик вводимых цифр
        MOV        #DECBUF,R2    ;буфер, куда сохранять цифры
2$:        EMT        6
        CMPB    #3,R0    ;если нажали КТ - то отмена
        BEQ        1CANS
        CMPB    #12,R0    ;конец ввода
        BEQ        10$
        CMPB    #30,R0    ;забой
        BNE        1$
        TST        R1        ;что-то вводили?
        BEQ        2$        ;нет, игнорируем
        EMT        16
        DEC        R1        ;да, отменим последнюю цифру
        DEC        R2
        BR        2$

1$:        CMPB    R0,#'0    ;если не цифры
        BLO    2$
        CMPB    R0,#'9
        BHI        2$        ;то тоже игнорируем
        CMP        R1,#5    ;больше 5 цифр не вводить
        BGE        2$
        EMT        16
        SUB        #'0,R0    ;получим число
        MOVB    R0,(R2)+    ;и сохраним его
        INC        R1        ;увеличим счётчик введённые чисел
        BR        2$

10$:    TST        R1        ;если нажали enter до ввода числа,
        BEQ        3$        ;то это означает просто согласие со значением по умолчанию
        ;а иначе интерпретируем введённое число
        MOV        #DECBUF,R2
        CLR        R3        ;тут накапливается результат
4$:        ASL        R3
        MOV        R3,R4
        ASL        R3
        ASL        R3
        ADD        R4,R3
        MOVB    (R2)+,R0
        ADD        R0,R3
        SOB        R1,4$
        MOV        R3,R1
        BR        5$

1CANS:    TST        R1    ;если нажали esc, когда вводили число
        BNE        3$    ;то это означает, просто отмену и согласие со значением по умолчанию
5$:        TST        (PC)+    ;а если нажали до ввода числа - значит отказ от теста
3$:        SEC
        RETURN
;вывод десятичного числа с подавлением ведущих нулей
;вход:  R1 - число
DECOU$: JSR        R5,PUSHA
        CLR        R5
        MOV        #CONST,R2
6$:        CLR        R0
        MOV        (R2)+,R4
        BEQ        2$
1$:        SUB        R4,R1
        BCS        0$
        INC        R0
        BR        1$
0$:        ADD        R4,R1
        BIS        R0,R5
        BNE        4$
        CMP        #1,R4
        BNE        6$
4$:        ADD        #'0,R0
        EMT        16
        BR        6$
2$:        RETURN

        .END