;THIS IS THE VA212 INTERRUPT SERVICE MODULE
;
$TITLE(SYSTEM TICKER INTERR SERVICE ROUTINE)
;
MOD_103:JB	SNDOT_FLG,ST_103
	JNB	SP_FLG,MMM103		;SEND SP DISCONNECT
	CLR	C
	SJMP	MMMM103
MMM103:	MOV	C,DTXD		;READ BIT FROM DTE
MMMM103:MOV	MTXD,C		;SEND TO PHONE LINE
	MOV	C,RXD_103	;READ BIT FROM LINE
	MOV	RCVD,C		;SEND TO DTE
	JC	R103		;SEE MK, NOT RCV SP
	JB	LGSP_FLG,RR103	;ALREADY SEE LONG SP
	CLR	C
	MOV	A,LG_SP
	SUBB	A,#1
	MOV	LG_SP,A
	MOV	A,LG_SP1
	SUBB	A,#0
	MOV	LG_SP1,A
	JNC	RR103
	SETB	LGSP_FLG
	MOV	LG_SP,#0
	MOV	LG_SP1,#0
RR103:	POP	PSW
	POP	ACC
	RETI
R103:
;	CLR	LGSP_FLG
	MOV	LG_SP,#LOW(1800*5)
	MOV	LG_SP1,#HIGH(1800*5)
	SJMP	RR103
;
ST_103:	MOV	C,DOT_BIT	;SEND DOTTING PATTERN OUT
				;ASSUMING DOT_BIT & CORE_CNT HAS BEEN
				;INITIALIZED TO 21
	MOV	MTXD,C		;SEND DOTTING PATTERN OUT
	DJNZ	CORE_CNT,DOT_103
	CPL	DOT_BIT
	MOV	CORE_CNT,#21
;
DOT_103:JNB	HUNT_FLG,DISTORT;HUNT FOR AN EDGE
	JB	RXD_103,RET_103	;DO I SEE A SP?
	CLR	HUNT_FLG	;YES,SEE SPACE
	MOV	M_CNT,#1	;M_CNT TO COUNT& CHK 25PERCENT DISTORTION
	MOV	FRAM_CNT,#30	;FRAM_CNT USED HERE TO CNT SAMPLES
RET_103:POP	PSW
	POP	ACC
	RETI
;
DISTORT:JB	RXD_103,DTORT1	;A MK, CHK WHETHER WINDOW TIME IS UP
	INC	M_CNT		;A SP, INC CNT
DTORT1:	DJNZ	FRAM_CNT,RET_103;IS WINDOW TIME UP?
	SETB	HUNT_FLG	;YES, CHK DISTORTION
	CLR	C
	MOV	A,M_CNT
	SUBB	A,#15		;M_CNT HAS TO BE GREATER THAN 15 
				;AND SMALLER THAN 26
	JC	DTORT2
	SUBB	A,#11
	JNC	DTORT2
	JNB	DOT_ERR,RET_103	;NO ERROR, NO NEED TO FLASH LIGHT
	MOV	A,MMTY_CNT	;PREVIOUS ERROR,HAVE I FLASHED FOR
	JZ	DTORT3		;A WHILE?
	DEC	MMTY_CNT	;NOT YET
	JMP	RET_103
DTORT3:	CLR	DOT_ERR
	JMP	RET_103
DTORT2:	SETB	DOT_ERR
	MOV	MMTY_CNT,#0EFH
	JMP	RET_103
;
;::::::::::::
GO_103:	JMP	MOD_103
;
$EJECT
%HEADER(SYSTEM TICKER INTERR,NONE,NONE,NONE,
;THE PHYSICAL TIMER 1 IS USED AS THE SYSTEM TICKER. WHEN A TICK
;OCCURS, SYS CHECKS TO SEE WHETHER IT NEEDS TO HANDLE THE INTERFACE
;BETWEEN THE MODEM & THE DTE.
;ALSO THIS ROUTINE ONLY HANDLE THE INTERFACE BETWEEN MODEM & DTE, THE HANDLING
;BETWEEN MODEM & PHONE LINE SIDE IS DONE BY SCT & SCR (XSMIT & RCV) CLOCKS
;ALSO NOTE THAT THE TIME CONSTANT FOR THE TIMER SHOULD BE INITIALIZED AT
;POWER UP TO THE RIGHT BAUD RATE OF 1200 OR 300
;NOTE THAT THIS IS ONLY FOR ASYN MODE
;
)
;
TYM_INT:	PUSH	ACC	;SAVE THE ACC BECAUSE IT WILL BE USED THRU
	PUSH	PSW		;SAVE THE REG BNK INFO
	JB	BBB_FLG,TTT1
	JNB	B212_FLG,GO_103
TTT1:	MOV	C,TXD_PIP	;PIPELINE TO SYN XSMIT WITH TICKER
	MOV	RCVD,C
	MOV	C,DTXD		;READ BIT ASAP TO MAINTAIN SYN
	MOV	DRXD_BIT,C	;STORE IT
;
;
$EJECT
%HEADER(RCV ASY DATA FROM DTE,NONE,NONE,ALL,
;COMES HERE VIA THE INTERNAL SYSTEM TICKER INTERR_WHICH IS PHYSICAL TIMER1
;THE SYSTEM TICKER INTERR AT A CERTAIN RATE TO ENABLE THE SYS TO SAMPLE THE
;DATA FROM THE DTE AND DO THE FRAMING ETC_THE INDIVIUAL BITS ARE SENT TO A 
;FIFO TO BE SENT OUT TO THE PHONE LINE_IN ADDITION_ THE FRAMED BYTE IS PUT
;IN A HOLDING BUFFER FOR SYSTEM USE_OTHER DETAILS INCLUDE STRIP STOP BITS
;TO COMPENSATE FOR THE SLIGHT DIFFERENCE IN TIMING BETWEEN THE DTE RATE AND
;THE LINE RATE_ALSO SET A FRAME ERR FLG TO ALERT THE SYSTEM FOR POSSIBLE BREAK
;SITUATION_THE 2M+3 RULE
;NOTE THAT THE FIFO IS ALWAYS FILLED WITH 1 ANYWAY, SO THERE IS ONLY STRIP
;STOP BIT. THE INSERT STOP BIT IS AUTOMATIC WHEN THE FIFO IS EMPTY
;	TICK COUNTER,KNOWN AS RCV_TICK
;	WALKING ZERO PTR,RCV_PTR, THE IN-PTR TO THE FIFO, RCV_BUF
;	THE FIFO,RCV_BUF
;	CORE_CNT, TRACKS THE BITS WITHIN THE CORE TO PT TO LAST BIT
;	M_CNT, COUNTS WHETHER 2M+3 SPACE BITS HAVE BEEN SENT IN BREAK SITUATION
;THIS IS FOR ASNY MODE ONLY
;
;TO SET THE NOMENCLATURE STRAIGHT:
;A FRAME IS THE SEGMENT OF BITS DELIMITED BY A START BIT AND A STOP BIT
;INCLUDING THE START AND STOP BIT. UNDER A BREAK OR STRIP STOP BIT SITUATION
;THE STOP BIT MAY NOT BE IN A FRAME. A NORMAL FRAME CONSISTS OF EITHER
;9 OR 10 BITS, DEPENDING ON THE USER'S NEED. TAKE THE CASE OF A 10 BIT
;FRAME, EXCLUDING THE START & STOP BITS, THAT LEAVES YOU WITH 8 BITS, WHICH
;IS THE CORE. IN THE CASE OF A 9-BIT FRAME, THE CORE IS 7 BITS.
;FOR A 8-BIT CORE, THE WHOLE CORE IS STORED IN THE HOLDING BUFFER RXD_BYT
)
;
;
RCV:	JB	RX_FLG,RCV1	;IS A BYTE IN PROGRESS?
	JB	DRXD_BIT,EXIT4	;SAMPLE THE DATA BIT
				;A MARK, NOT START BIT
	SETB	RX_FLG		;POSSIBLE START BIT, SET RX_FLG
				;HALF BIT DELAY
				;BIT DELAY COUNT
	MOV	RCV_TICK,#04H	;START BIT IS HALF BIT DELAY
	JMP	XSMIT		;WAIT TILL TICK CNTR OVF AND SEE IF START BIT STILL THERE
;
RCV1:	JB	STRT_FLG,RCV2	;HAVE I SEEN A VALID START BIT?
	DJNZ	RCV_TICK,EXIT4	;NO, IS IT TIME tO SAMPLE START BIT?
	JB	DRXD_BIT,RCV6	;YES, TICK CNT OVF
				;SEE A MARK,A GLITCH, RESET RX_FLG
	MOV	RCV_TICK,DBIT_CNT	;LOAD TICK CNTR FOR BIT DELAY/FRAME,DESERIALIZE
	MOV	CORE_CNT,DCOR_CNT
	JB	BBB_FLG,EXIT2
	CLR	IP.0		;LOWER SCT PRIORITY
	MOV	A,RCV_PTR		;A VALID START BIT
	JNB	ACC.0,STRT3		;IS PTR AT LSB
	JB	ACC.7,STRT1		;NOT AT FAR END, OK
	RR	A			;AT FAR END STRIP STOP BIT
	RR	A
STRT3:	RL	A			;INSERT STOP BIT
	MOV	RCV_PTR,A
STRT1:	ANL	A,RCV_BUF		;INSERT START BIT
	MOV	RCV_BUF,A
	MOV	A,RCV_PTR
	RL	A
	MOV	RCV_PTR,A
	SETB	IP.0			;RESTORE PRIORITY OF SCT
EXIT2:	SETB	STRT_FLG
	SETB	ZERO_FLG
EXIT4:	JMP	XSMIT
;;
RCV2:	DJNZ	RCV_TICK,EXIT4	;SEE START BIT, BUT NOT THE RT TIME TO SAMPLE BIT
	MOV	RCV_TICK,DBIT_CNT	;TIME TO SAMPLE BIT, BUT RELOAD TICK CNTR FIRST
;
	JB	BBB_FLG,RCV23		;BIT BY BIT MODE FOR DIALER
	JNB	CORFIN_FLG,RCV3	;END OF CORE?
	JB	BRK_FLG,BREAK	;YES,IN BRK ?
				;NO, SEE DATA BIT
	JB	DRXD_BIT,DDRDY	;SEE MARK, A VALID STOP BIT
;	SETB	FRM_FLG		;NO STOP BIT, SET FRAME ERRoR FLG
				;IGNORE FRAME ERROR FOR TIME BEING
;	JNB	ZERO_FLG,FOR_STP;ZERO FLG SET?
	SETB	BRK_FLG		;YES, AND STP BIT IS SP=>BREAK
	SETB	CORFIN_FLG	;FORCE CORE_FINISH FOR NEXT PASS TO HANDLE BRK
	MOV	A,DM_CNT	;DM_CNT INIT AT PWR UP
	ADD	A,#4		;M+4, LAST FRAME WITHOUT STP IS M-1, THEN 
				;M-1+M+4=2M+3

	MOV	M_CNT,A
	JMP	MARK1
;
DDRDY:	CLR	IP.0		;LOWER SCT PRIORITY
	MOV	A,RCV_PTR	;SEE A STOP BIT
	CPL	A
	ANL	A,#11110000B
	JNZ	DDRDY2		;STRIP STOP BIT HERE
	MOV	A,RCV_PTR
	RL	A
	MOV	RCV_PTR,A
DDRDY2:	ANL	FLAGS,#00000000B;CLEAR ZERO,STRT,RX,CORFIN,BREAK FLAGS
	SETB	IP.0
	JMP	XSMIT
;
DDRDY1:	ANL	FLAGS,#00000000B
	SETB	DRDY_FLG
	MOV	RXD_BYT,DES_BUF
	JMP	XSMIT
;
BREAK:	MOV	A,M_CNT		;CHK TO SEE WHETHER 2M+3 HAS BEEN MET
	JZ	BREAK1		;YES, THEN CHK WHETHER A MK IS RCVD
	DEC	M_CNT
	SJMP	MARK1		;NOT YET 2M+3, INSERT SP
BREAK1:	JNB	DRXD_BIT,MARK1	;REACHED 2M+3, BUT STILL SEE SP, SND SP.
RCV6:	ANL	FLAGS,#00000000B;CLEAR ZERO,STRT,RX,CORFIN,BREAK FLAGS
	JMP	XSMIT
;
RCV23:	JNB	CORFIN_FLG,RCV20;END OF CORE?
	JB	BRK_FLG,BBRK	;SEE BREAK,BUT NO 2M+3 RULE HERE
	JB	DRXD_BIT,DDRDY1	;SEE VALID STOP BIT
	SETB	BRK_FLG		;NO STP BIT, CONSIDER AS BRK
	SETB	CORFIN_FLG	;FORCE NEXT PASS TO CHK FOR BRK
	JMP	XSMIT
RCV20:	DJNZ	CORE_CNT,RCV21
	SETB	CORFIN_FLG
RCV21:	MOV	C,DRXD_BIT
	MOV	A,DES_BUF
	RRC	A
	MOV	DES_BUF,A
	JNB	DRXD_BIT,RCV22
	CLR	ZERO_FLG
RCV22:	JMP	XSMIT
;
BBRK:	JNB	DRXD_BIT,XSMIT	;SEE SP, STILL IN BREAK
	ANL	FLAGS,#00000000B;SEE MK, CLR FLAGS
	JMP	XSMIT
;
RCV3:	DJNZ	CORE_CNT,RCV8	;LAST BIT OF CORE?
RCV7:	SETB	CORFIN_FLG	;SET CORE FINISH FLG
RCV8:	CLR	IP.0
	NOP
	JNB	DRXD_BIT,MARK1	;A MARK?
	CLR	ZERO_FLG	;A MARK,VALID STOP BIT
	JMP	MARK
MARK1:	MOV	A,RCV_PTR	;NO, A SPACE
	ANL	A,RCV_BUF
	MOV	RCV_BUF,A
MARK:	MOV	A,RCV_PTR	;UPDATE RCV_PTR
	JNB	ACC.7,MARK2	;FAR END, DON'T ROTATE
	RL	A
	MOV	RCV_PTR,A
MARK2:	SETB	IP.0
;
;GO TO XSMIT FROM HERE
;
$EJECT
%HEADER(SEND ASYN DATA TO DTE,NONE,NONE,ALL,
;COMES HERE ALSO VIA THE SYSTEM TICKER INTERR_WHICH IS PHYSICAL TIMER1
;IT GRAPS A DESCRAMBLED BIT FROM AN INTERNAL FIFO AND SEND IT TO THE DTE
;	XSMIT TICK COUNTER,XMT_TICK
;	FRAM_CNT, CNTS  BIT WITHIN A FRAME
;	XMT_PTR, THE IN_PTR TO XMT_BUF, THE FIFO
;	O_PTR, REMEMBER WHERE A MARK HAS BEEN INSERTED
;
;THIS IS FOR ASYN MOdE ONLY
)
XSMIT:	DJNZ	XMT_TICK,XXIT	;TIME TO SEND BIT OUT?
	MOV	XMT_TICK,DBIT_CNT
;
;THE ABOVE INSTR MAY BE ASSEMBLED WRONG BY V1.0 ASSEMBLER
;
	JB	BBB_FLG,XBBB
XMT1:	CLR	IP.2		;LOWER PRIORITY OF SCR INTERR
	MOV	A,XMT_PTR
	JB	ACC.2,XMT4	;HAS PTR HIT THE BOUNDARY?
	JNB	BBRK_FLG,XMT2	;YES, BUT NOT BRK, SO GIVE IT A MK
				;WITHOUT UPDATE PTR
	ANL	XMT_BUF2,#11111011B
				;HIT BOUND, IN BRK, GIVE THEM SP
	SJMP	XMT2
XMT4:	RR	A		;NOT YET, SO UPDATE PTR
	MOV	XMT_PTR,A
XMT2:	MOV	A,O_PTR		;ALSO UPDATE O_PTR TO TRACK THE INSERTED
				;MARK FOR 2 NULL SITUATION
	RR	A		;PTR HIT BOUND, DON'T UPDATE PTR, BUT KEEP
				;SHIFTING FIFO AS THERE MAY BE RESIDUE BITS
				;INT XMT_BUF1
	MOV	O_PTR,A
	SETB	C
	MOV	A,XMT_BUF2	;HI BYTE OF BUFFER
	RRC	A
	MOV	XMT_BUF2,A
	MOV	A,XMT_BUF1	;LO BYTE
	RRC	A		;NOW BIT IN CY
	MOV	XMT_BUF1,A
	MOV	TXD_PIP,C	;PUT INTO PIP LINE
XMT3:	SETB	IP.2		;RESTORE PRIORITY
XXIT:	POP	PSW
	POP	ACC
	RETI
;
XBBB:	JNB	XBIT_FLG,XXIT	;BIT READY FROM SND_CHR OR SND_STR?
	MOV	C,TXD_BBB	;YES, PUT INTO PIPELINE & CLR FLG
	MOV	TXD_PIP,C
	CLR	XBIT_FLG
	JMP	XXIT
;
$TITLE(THE SCT INTERR SERVICE ROUTINE)
$EJECT
;
%HEADER(SEND A BIT TO LINE,NONE,NONE,ALL,
;COMES HERE WHEN EDGE-TRIGGERED BY THE SCT CLOCK(THE XSMIT CLK)
;EDGE-TRIGGERED BY THE SCT CLOCK, THIS ROUTINE GRABS A BIT FROM THE RCV_BUF
;& SCAMBLE IT IF NECESSARY, THEN SEND IT OUT TO THE TELEPHONE LINE. THE SCT
;CLOCK IS SUPPLIED BY THE EXTERNAL WORLD. 
;	THE RCV_BUF, FROM WHICH A BIT IS GRABED & SENT TO LINE
;	RCV_PTR, A WALKING 0 PTR FOR THE FIFO RCV_BUF
;
;THIS IS FOR ASYN MODE ONLY
)
;
SCT_INT:PUSH	ACC		;SAVE ACC, PSW
	PUSH	PSW
	MOV	C,SCT_PIP
	MOV	MTXD,C		;SEND IT OUT ****5/15/85
	JB	SNDOT_FLG,SND_DOT	;SEND DOTTING TO LINE
	CLR	C
	JB	SP_FLG,SPACE1	;SEND SP DISCONNECT
	JB	SYN_FLG,SYN_MOD
	SETB	C
	MOV	A,RCV_PTR
	JB	ACC.0,SCT1	;PTR NOT AT END YET
	JNB	STRT_FLG,SPACE1	;PTR AT END, NO STRT_FLg, INSERT STP BIT
				;IN THE MIDDLE OF BYTE, BIG TROUBLE
	MOV	A,RCV_BUF
	RRC	A		;DO IT, WHAT THE HECK
	MOV	RCV_BUF,A
	SJMP	SPACE1
SYN_MOD:JNB	SDMK_FLG,SSYN1
	SETB	C
	SJMP	SPACE1
SSYN1:	MOV	C,DTXD
	SJMP	SPACE1		;SYN MODE, JUST LET BIT THRU
SCT1:	MOV	A,RCV_BUF
	RRC	A		;ROTATE BIT INTO CY
	MOV	RCV_BUF,A	;UPDATE BUFFEER
	MOV	A,RCV_PTR
	RR	A
	MOV	RCV_PTR,A
SPACE1:	JNB	SCRM_FLG,M103	;DON'T SCRAMBLE
				;BIT IN CY, START SCRAMBLING
	MOV	A,SCM1		;LEAST SIG BYTE
	RLC	A		;BIT IS MOVED INTO LSB
	MOV	SCM1,A
	MOV	A,SCM2
	RRC	A
	MOV	SCM2,A
	MOV	A,SCM3
	RLC	A
	MOV	SCM3,A
	XRL	A,SCM2
	RR	A
	ANL	A,#01
	XRL	A,SCM1
	MOV	SCM1,A
	RRC	A		;SCRAMBLE BIT IN CY
M103:	MOV	SCT_PIP,C	;SEND BIT OUT TO LINE
	POP	PSW
	POP	ACC
	RETI
SND_DOT:CPL	DOT_BIT
	MOV	C,DOT_BIT

	JMP	SPACE1
;
;
$TITLE(SCR INTERRUPT SERVICE ROUTINE)
$EJECT
;
%HEADER(HANDLE SCR INTERR,NONE,NONE,NONE,
;COMES HERE VIA THE SCR INTERR. UPON THIS, THE ROUTINE GRABS THE BIT FROM THE
;PHONE LINE, DESCRAMBLE IT IF NECESSARY, PUTS IT IN XMT_BUF, 16 BIT FIFO
; WHICH IS POINTED AT BY THE XMT_PTR, A WALKING 0 PTR
;THIS IS FOR ASYN MODE ONLY
;ALSO, DPTR IS USED TO CNT THE NUMBER OF SPACE RECEIVED FOR LONG SP DISCONNECT
;IRT_CNT STORES THE NUM OF UNSCRAMBLED MK RECEIVED
)
;
BRK1:
;	CLR	LGSP_FLG	;CLR CNT FOR LONG SP DISCON
	MOV	LG_SP,#LOW(1800)
	MOV	LG_SP1,#HIGH(1800)
	CLR	BBRK_FLG	;SEE MARK, CLR BREAK
	CLR	ZZRO_FLG
	SETB	HUNT_FLG
	JMP	MMARK
;
BRK:	JB	DLIN_RXD,BRK1
	JB	LGSP_FLG,BRKX		;ALREADY SEE LG SP
	CLR	C
	MOV	A,LG_SP
	SUBB	A,#01
	MOV	LG_SP,A
	MOV	A,LG_SP1
	SUBB	A,#0
	MOV	LG_SP1,A
	JNC	BRKX
	SETB	LGSP_FLG
BRKX:	JMP	SSPACE
;
;
RCV_DOT:JNB	HUNT_FLG,CHK_DOT
	JC	DOT3		;SEE FIRST ZERO
	CLR	HUNT_FLG
	MOV	DLIN_RXD,C	;STORE RCV BIT
	JMP	DOT7
CHK_DOT:MOV	ACC.7,C		;MOVE THE BIT INTO CY
	MOV	C,DLIN_RXD
	XRL	A,PSW
	ANL	A,#10000000B
	JZ	DOT2
	JNB	DOT_ERR,DOT4	;NO PREVIOUS ERROR
	CLR	C
	MOV	A,MMTY_CNT
	SUBB	A,#1		;LET THE LIGHT FLASH FOR 4 SEC
	MOV	MMTY_CNT,A
	MOV	A,MMTY_CNT+1
	SUBB	A,#0
	MOV	MMTY_CNT+1,A
	JNC	DOT4
	CLR	DOT_ERR
DOT4:	CPL	DLIN_RXD
	JMP	DOT7
DOT2:	SETB	DOT_ERR
	MOV	MMTY_CNT,#LOW(1200)
	MOV	MMTY_CNT+1,#HIGH(1200)
DOT3:	JMP	DOT7
;
;
SCR_INT:	PUSH	ACC
	PUSH	PSW		;SAVE REG BNK INFO
	MOV	C,RXD_212	;GRAB BIT FROM LINE
;	CPL	C		;INVERTED DATA COMING IN
	MOV	DDLN_RXD,C	;STORE UN-DESCRM BIT FOR IRT DETECTION
	MOV	A,DSCM1
	RLC	A
	MOV	DSCM1,A
	MOV	A,DSCM2
	RRC	A
	MOV	DSCM2,A
	MOV	A,DSCM3
	RLC	A
	MOV	DSCM3,A
	XRL	A,DSCM2
	RR	A
	XRL	A,DSCM1
	RRC	A
MM103:	JB	RVDOT_FLG,RCV_DOT
	JB	SYN_FLG,SYNMOD
	MOV	DLIN_RXD,C	;STORE BIT HERE
	JB	BBRK_FLG,BRK	;IS BREAK FLG SET
	JB	HUNT_FLG,SCR1	;NO BRK,LOOK FOR A MK-SP XSITION?
				;NOTE HUNT_FLG IS SET UPON POWER UP
	DJNZ	FRAM_CNT,SCR2	;IS THIS THE STP BIT
	JNB	DLIN_RXD,SCR3	;YES, VALID STP BIT?
STP1:	SETB	HUNT_FLG
	CLR	NULL_FLG
	CLR	ZZRO_FLG
;:::::::::
;	CLR	LGSP_FLG	;CLR CNT FOR LONG SPACE
	JMP	MMARK		;SeE VALID STOP BIT
SCR1:
;	JB	DLIN_RXD,DOT1	;HUNT FOR MK_SP XSITION
	JB	DLIN_RXD,MMARK
SCR11:	CLR	HUNT_FLG	;SEE START BIT HERE
	SETB	ZZRO_FLG	;SET tO CHK FOR ALL ZERO CORE
	MOV	A,DFRM_CNT	;INIT FRAME COUNT
	DEC	A
	MOV	FRAM_CNT,A
	MOV	A,XMT_PTR
	JNB	ACC.2,ADD_STP1	;IF PTR AT BOUND, INSERT MK, THEN START BIT
SCR22:	JMP	SSPACE
SCR2:	JNB	DLIN_RXD,SSPACE	;HANDLE CORE
	CLR	ZZRO_FLG	;SEE MARK, CLR AlL ZERO FLG
;::::::::::::
;	CLR	LGSP_FLG		;CLR LNG SP CNT
	SJMP	MMARK
;
SYNMOD:	MOV	DLIN_RXD,C
	JB	CLP_SYN,SYNMOD2		;CLAMP LINE TO DTE
	MOV	RCVD,C		;SYN MODE
SYNMOD2:JC	SYNMOD1		;SEE MK
	JB	LGSP_FLG,DOT1	;ALREADY SEE LNG SP
	CLR	C
	MOV	A,LG_SP
	SUBB	A,#01
	MOV	LG_SP,A
	MOV	A,LG_SP1
	SUBB	A,#0
	MOV	LG_SP1,A
	JNC	DOT1
	SETB	LGSP_FLG
	SJMP	DOT1
;
SYNMOD1:
;	CLR	LGSP_FLG
	MOV	LG_SP,#LOW(1800)
	MOV	LG_SP1,#HIGH(1800)
	SJMP	DOT1		;HANDLE RTRT IN SYN MODE
;
SET_BRK:SETB	BBRK_FLG
	MOV	LG_SP,#LOW(1800)
	MOV	LG_SP1,#HIGH(1800)
	MOV	A,O_PTR		;BRK SITUATION, RE_INSRT SPACE
	ANL	XMT_BUF1,A
	CLR	NULL_FLG
SSPACE:
	MOV	A,XMT_PTR	;INSERT A SPACE
	ANL	A,XMT_BUF2
	MOV	XMT_BUF2,A
MMARK:	MOV	A,XMT_PTR
	JNB	ACC.7,DOT1		;PTR HITS BOUNDARY
					;DON'T WRAP AROUND
MMARK1:	RL	A
	MOV	XMT_PTR,A
DOT1:	JB	DDLN_RXD,DOT5		;IS THIS AN UNSCRAMBLED MK?
	MOV	IRT_CNT,#0FFH		;NO, PRESET IRT_CNT
DOT7:	POP	PSW
	POP	ACC
	RETI
DOT5:	MOV	A,IRT_CNT
	JZ	DOT6
	DEC	A
	MOV	IRT_CNT,A
DOT6:	POP	PSW
	POP	ACC
	RETI
SCR3:	JB	ZZRO_FLG,ADD_STX;SPACE, BUT NON_ZERO CORE, INSERT STP BIT
	CLR	NULL_FLG
	JMP	ADD_STP
ADD_STX:JB	NULL_FLG,SET_BRK;ZERO_CORE, NULL_FLG MEANS BREAK
	SETB	NULL_FLG	;ZERO CORE, POSSIBLE NULL
ADD_STP:MOV	A,DFRM_CNT
	DEC	A
	MOV	FRAM_CNT,A
	SETB	ZZRO_FLG
	CLR	HUNT_FLG
	MOV	A,XMT_PTR	;SET O_PTR TO TRACK WHERE MK IS INSERTED
	MOV	O_PTR,A
ADD_STP1:	RL	A
	MOV	XMT_PTR,A
	JMP	SSPACE
;
$EJECT