$ROM(LARGE)
$DEBUG NOSYMBOLS NOPAGING

/*THIS PLM/51 PROGRAM IS THE CONTROL FOR THE VIKING
ELECTRONICS UNIVERSAL PRODUCT TESTER.


MAIN MODULE

VERSION 1.1					26 JULY 1988
BY							BILL HEIDEMAN	*/


TSTR_MAIN:	DO;
$NOLIST
$INCLUDE(REG51.DCL)

$LIST
$INCLUDE(TSTR.PUB)


/********************************************
*											*
*	THESE ARE THE EXTERNAL PROCEDURES		*
*											*
********************************************/

	BOARD_TEST: PROCEDURE (SELECT) EXTERNAL;
		DCL SELECT BYTE;
	END	BOARD_TEST;


/********************************************
*											*
*	THESE ARE THE PUBLIC PROCEDURES			*
*											*
********************************************/

	WAITM: PROCEDURE (LENGTH) PUBLIC;
		DCL (LENGTH,I) BYTE;
		DO I=1 TO LENGTH;
			CALL TIME(10);
		END;
	END WAITM;


/********************************************
*											*
*	THESE ARE THE INTERNAL PROCEDURES		*
*											*
********************************************/

	KEY_DECODE: PROCEDURE USING 1;
		DCL (MASK2,COUNT) BYTE;

		MASK2=1;
		COUNT=0;
		DO WHILE (MASK2 AND NOT(KEY_DEBN))=0;
			COUNT=COUNT+1;
			MASK2=SHL(MASK2,1);
		END;
		MASK2=10H;
		DO WHILE (MASK2 AND NOT(KEY_DEBN))=0;
			COUNT=COUNT+3;
			MASK2=SHL(MASK2,1);
		END;

		IF COUNT=0AH THEN COUNT=0FFH;
		ELSE IF COUNT=9 THEN COUNT=0AH;
		COUNT=COUNT+1;
		KEY_DATA=COUNT;
	END	KEY_DECODE;

	BCD_CONV: PROCEDURE (ITEM) WORD USING 1;
		DCL (BCDN,ITEM,COUNT,ZERO) BYTE;
		DCL (RESULT) WORD;

		ZERO=0;
		COUNT=SHR(ITEM,4);
		BCDN=0;
		DO WHILE COUNT<>0;
			BCDN=BCDN+16H;
			BCDN=DEC(BCDN);
			COUNT=COUNT-1;
		END;

		COUNT=(ITEM AND 0FH)+ZERO;	/*	FORM BCD OF LSB	*/
		COUNT=DEC(COUNT);
		BCDN=BCDN+COUNT;
		BCDN=DEC(BCDN);

		RESULT=(DOUBLE(BCDN AND 0FH)) OR
			 (SHL(DOUBLE(BCDN AND 0F0H),4));
		RETURN RESULT;
	END BCD_CONV;


	DISP_MON: PROCEDURE USING 1;
		DISP_DATA(4)=MODE_BUFF;
		DISP_DATA(0)=LOW(BCD_CONV(ERROR_CODE));
		DISP_DATA(1)=HIGH(BCD_CONV(ERROR_CODE));
		IF MODE_BUFF=5 THEN DO;
			DISP_DATA(2)=LOW(BCD_CONV(BOARD_BUFF));
			DISP_DATA(3)=HIGH(BCD_CONV(BOARD_BUFF));
		END;
		ELSE DO;
			DISP_DATA(2)=LOW(BCD_CONV(TEST_BUFF));
			DISP_DATA(3)=HIGH(BCD_CONV(TEST_BUFF));
		END;
	END DISP_MON;


	DISP_FORMAT: PROCEDURE USING 1;
		DCL DEC_TBL (16) BYTE CONSTANT(6FH,03H,5EH,1FH,33H,
					3DH,7DH,07H,7FH,37H,1,2,4,8,10H,20H);
		DCL (I,VALUE,DATA) BYTE;

		DO I=0 TO 3;
			DATA=DISP_DATA(I);
			DISP_BUFF(I)=DEC_TBL(DATA);
		END;
		VALUE=DEC_TBL(DISP_DATA(4));
		DISP_BUFF(4)=SHR(VALUE,4);

		DISP_BUFF(0)=(DISP_BUFF(0)) OR (ROR(VALUE,1) AND 80H);
		DISP_BUFF(1)=(DISP_BUFF(1)) OR (ROR(VALUE,3) AND 80H);
		DISP_BUFF(2)=(DISP_BUFF(2)) OR (ROR(VALUE,2) AND 80H);
		DISP_BUFF(3)=(DISP_BUFF(3)) OR (ROR(VALUE,4) AND 80H);

		IF CURSOR<>0 THEN DO;
			IF (FLASH_CNT AND 1)=0 THEN DO;
				IF CURSOR<>1 THEN DISP_BUFF(5-CURSOR)=
					(DISP_BUFF(5-CURSOR) AND 80H);
				ELSE DO;
					DISP_BUFF(0)=(DISP_BUFF(0) AND 7FH);
					DISP_BUFF(1)=(DISP_BUFF(1) AND 7FH);
					DISP_BUFF(2)=(DISP_BUFF(2) AND 7FH);
					DISP_BUFF(3)=(DISP_BUFF(3) AND 7FH);
					DISP_BUFF(4)=0;
				END;
			END;
		END;

		ELSE IF ((FAULT<>0) AND ((FLASH_CNT AND 1)=0)) THEN DO;
			DISP_BUFF(0)=(DISP_BUFF(0) AND 80H);
			DISP_BUFF(1)=(DISP_BUFF(1) AND 80H);
		END;
	END DISP_FORMAT;


	RESET_STATS: PROCEDURE;
		BD_COUNT_LOW=0;
		BD_COUNT_HIGH=0;
	END RESET_STATS;


	KEY_MON: PROCEDURE;
		KEY_EDGE=0;
		IF KEY_DATA=0BH THEN DO;
			IF CURSOR=5 THEN CURSOR=1;
			ELSE CURSOR=CURSOR+1;
		END;

		ELSE IF KEY_DATA=0CH THEN DO;
			IF CURSOR=1 THEN
				COMMND=MODE;
			ELSE IF MODE_BUFF=ERASE THEN
				CALL RESET_STATS;
			ELSE COMMND=TEST;
			CURSOR=0;
		END;

		ELSE DO CASE CURSOR;
			COMMND=REPEAT;	/*	CASE 0	*/

			DO;				/*	CASE 1	*/
				MODE_BUFF=KEY_DATA;
				CURSOR=2;
			END;

			DO;				/*	CASE 2	*/
				IF MODE_BUFF=5 THEN BOARD_BUFF=
					((KEY_DATA*10)+DISP_DATA(2));
				ELSE TEST_BUFF=((KEY_DATA*10)+DISP_DATA(2));
				CURSOR=3;
			END;

			DO;				/*	CASE 3	*/
				IF MODE_BUFF=5 THEN BOARD_BUFF=
					((DISP_DATA(3)*10)+KEY_DATA);
				ELSE TEST_BUFF=((DISP_DATA(3)*10)+KEY_DATA);
				CURSOR=4;
			END;

			DO;				/*	CASE 4	*/
				ERROR_CODE=(KEY_DATA*10)+DISP_DATA(0);
				CURSOR=5;
			END;

			DO;				/*	CASE 5	*/
				ERROR_CODE=(DISP_DATA(1)*10)+KEY_DATA;
				CURSOR=1;
			END;
		END;
	END KEY_MON;


	BCD_CONVM: PROCEDURE (ITEM) WORD;
		DCL (BCDN,ITEM,COUNT,ZERO) BYTE;
		DCL (RESULT) WORD;

		ZERO=0;
		COUNT=SHR(ITEM,4);
		BCDN=0;
		DO WHILE COUNT<>0;
			BCDN=BCDN+16H;
			BCDN=DEC(BCDN);
			COUNT=COUNT-1;
		END;

		COUNT=(ITEM AND 0FH)+ZERO;	/*	FORM BCD OF LSB	*/
		COUNT=DEC(COUNT);
		BCDN=BCDN+COUNT;
		BCDN=DEC(BCDN);

		RESULT=(DOUBLE(BCDN AND 0FH)) OR
			 (SHL(DOUBLE(BCDN AND 0F0H),4));
		RETURN RESULT;
	END BCD_CONVM;


	SND_MSG: PROCEDURE;
		DCL (ASCII,NUM,I) BYTE;
		CODE_PNTR=0;
		NUM=0;
		DO WHILE NUM<>0FFH;
			NUM=CODE_DATA(CODE_PNTR);
			IF NUM<>0FFH THEN DO;
				IF CODE_PNTR<2 THEN
					ASCII=SHR(NUM,4)+30H;
				ELSE ASCII=HIGH(BCD_CONVM(NUM))+30H;
				TI=0;
				SBUF=ASCII;
				DO WHILE TI=0;
				END;
				IF CODE_PNTR<2 THEN
					ASCII=(NUM AND 0FH)+30H;
				ELSE ASCII=LOW(BCD_CONVM(NUM))+30H;
				TI=0;
				SBUF=ASCII;
				DO WHILE TI=0;	
				END;

				IF ((CODE_PNTR=25) OR (CODE_PNTR=51)
						OR (CODE_PNTR=77)) THEN DO;
					TI=0;
					SBUF=0AH;
					DO WHILE TI=0;
					END;
					TI=0;
					SBUF=0DH;
					DO WHILE TI=0;
					END;
				END;
				ELSE IF (CODE_PNTR AND 1)<>0 THEN DO;
					IF CODE_DATA(CODE_PNTR+1)<>0FFH
						THEN DO;
						TI=0;
						SBUF=',';
						DO WHILE TI=0;
						END;
					END;
				END;
			END;
			CODE_PNTR=CODE_PNTR+1;
		END;

		DO I=1 TO 8;
			TI=0;
			SBUF=0AH;
			DO WHILE TI=0;
			END;
			TI=0;
			SBUF=0DH;
			DO WHILE TI=0;
			END;
		END;
	END SND_MSG;


	COMMAND: PROCEDURE;
		DO CASE COMMND;
			COMMND=0;	/*	CASE 0	*/

			COMMND=0;	/*	CASE 1	*/

			DO;			/*	CASE 2	*/
				IF BOARD_BUFF=0 THEN
					CALL BOARD_TEST(BOARD_BUFF);
				ELSE DO;
					FAULT=0;
					IF MODE_BUFF=0 THEN DO;
						DO WHILE((FAULT=0) AND (TEST_BUFF<7));
							CALL BOARD_TEST(BOARD_BUFF);
							IF ERROR_CODE=99 THEN
								TEST_BUFF=TEST_BUFF+1;
						END;
						IF FAULT=0 THEN DO;
							TEST_BUFF=0;
							ERROR_CODE=0;
							EXP2_C=10H;
						END;
					END;

					ELSE DO;
						CODE_DATA(0)=BD_COUNT_HIGH;
						CODE_DATA(1)=BD_COUNT_LOW;
						CODE_DATA(2)=0FFH;
						CODE_PNTR=2;
						DO WHILE TEST_BUFF<>7;
							CALL BOARD_TEST(BOARD_BUFF);
							IF ERROR_CODE=99 THEN
								TEST_BUFF=TEST_BUFF+1;
							ELSE DO;
								CODE_DATA(CODE_PNTR)=
										TEST_BUFF;
								CODE_PNTR=CODE_PNTR+1;
								CODE_DATA(CODE_PNTR)=
										ERROR_CODE;
								CODE_PNTR=CODE_PNTR+1;
								CODE_DATA(CODE_PNTR)=0FFH;
							END;
						END;
						TEST_BUFF=0;
						ERROR_CODE=0;
						EXP2_C=10H;
						CALL SND_MSG;
						BD_COUNT_LOW=BD_COUNT_LOW+1;
						BD_COUNT_LOW=DEC(BD_COUNT_LOW);
						IF BD_COUNT_LOW=0 THEN DO;
							BD_COUNT_HIGH=BD_COUNT_HIGH+1;
							BD_COUNT_HIGH=DEC(BD_COUNT_HIGH);
						END;
					END;
				END;
			COMMND=0;
			END;

			DO;			/*	CASE 3	*/
				ERROR_CODE=99;
				CALL BOARD_TEST(BOARD_BUFF);
				COMMND=0;
			END;
		END;
	END	COMMAND;


/********************************************
*											*
*		THIS IS THE REAL TIME CLOCK			*
*											*
********************************************/

	TIMER_ZERO: PROCEDURE INTERRUPT 1 USING 1;
		TH0=0CAH;
		TL0=0FFH;	/*	SET TO 2 MSEC */
		TMR_CNT=TMR_CNT+1;
		TICK_2MSEC=1;
		IF MAIN_TIMER<>0 THEN MAIN_TIMER=MAIN_TIMER-1;

		DISP: DO;
			DCL (PNTR,MASK) BYTE;
			MASK=SHL(1,(BIT_CNT AND 7));
			PNTR=SHR(BIT_CNT,3);
			IF (DISP_BUFF(PNTR) AND MASK)<>0
				THEN INT1=1;
				ELSE INT1=0;
			INT0=1;
			IF BIT_CNT=75 THEN BIT_CNT=0;
			ELSE BIT_CNT=BIT_CNT+1;
			INT0=0;
			IF BIT_CNT=0 THEN DO;
				INT1=1;
				INT0=1;
				INT0=0;
				FLASH_CNT=FLASH_CNT+1;
			END;
		END DISP;

		KEY_IN:	DO;
			IF (TMR_CNT AND 7)=0 THEN DO;
				DCL (MASK,KEY_NEW) BYTE;

				MASK=0EFH;
				DO WHILE MASK<>0FEH;
					P1=(MASK OR 0FH);
					KEY_NEW=P1;
					IF (KEY_NEW AND 0FH)<>0FH THEN DO;
						IF KEY_NEW<>KEY_LAST THEN DO;
							KEY_LAST=KEY_NEW;
							MASK=0FEH;
						END;
						ELSE DO;
							IF KEY_NEW<>KEY_DEBN THEN DO;
								KEY_DEBN=KEY_NEW;
								CALL KEY_DECODE;
								KEY_EDGE=1;
								MASK=0FEH;
							END;
						END;
					END;
					ELSE DO;
						MASK=ROL(MASK,1);
						IF MASK=0FEH THEN DO;
							IF KEY_LAST<>0FFH THEN KEY_LAST=0FFH;
							ELSE KEY_DEBN=0FFH;
						END;
					END;
				END;
			END;
		END KEY_IN;

		IF BIT_CNT=0 THEN DO;
			CALL DISP_MON;
			CALL DISP_FORMAT;
		END;
	END TIMER_ZERO;


/************************************
*									*
*		THIS IS THE MAIN LOOP		*
*									*
***********************************/

	INIT: DO;
		DCL I BYTE;
		P1=0FFH;
		SCON=50H;	/* USART */
		TH1=0F5H;
		TL1=0F5H;
		TMOD=20H;

		TR0=1;
		TR1=1;
		IE=82H;

		DO I=0 TO 9;
			DISP_BUFF(I)=0;
		END;
		CURSOR=0;
		KEY_DATA=0;
		KEY_DEBN=0FFH;
		KEY_LAST=0FFH;
		COMMND=0;
		FAULT=0;
		ERROR_CODE=0;
		TEST_BUFF=0;
		BOARD_BUFF=1;
		MODE_BUFF=1;
		CALL RESET_STATS;

		CALL WAITM(250);
		EXP2_COM=82H;
		EXP3_COM=82H;
		EXP4_COM=8BH;

	END INIT;

	MAIN_LOOP: DO FOREVER;
		IF KEY_EDGE<>0 THEN 
			CALL KEY_MON;
		IF COMMND<>0 THEN 
			CALL COMMAND;
	END	MAIN_LOOP;

END TSTR_MAIN;