please dont rip this site

Scenix Lib IO OSI2 IR DA Lap

LapInfoSeg		MACRO
;********************************************************************************
;  LAP LAYER
;********************************************************************************
;
;Framing Layer Events
;
;	fl2lapMediaBusy()				;A byte has been received => the media is busy
;
;Payload Layer Events
;
;	pl2lapRxFrame(w=Type)				;Incomming frame of given type
;	pl2lapRxValid()					;Frame was valid
;	pl2lapRxError()					;Frame was invalid
;	pl2lapRxXIDData()				;XID data
;	pl2lapRxIData()					;I data
;	pl2lapRxUIData()				;UI data
;	lap2plRxIgnore()				;Tell the framing layer to ignore the frame
;
;	lap2plSNRMAccept()				;Accept connection and send reply
;	lap2plTxXIDCmd(w=Slot)				;Send a XID command frame
;	lap2plTxXIDRsp()				;Send a XID response frame
;	lap2plTxSimpleRsp()				;Send simple response frame
;	lap2plTxIRsp()					;Send an I frame
;	pl2lapTxIData(ret w=Data ret z=Last) call	;Request for data
;	pl2lapTxComplete()				;Complete indication
;
;	lap2plGenerateNewAddr				;Request that a new 32-bit address be generated
;
;LMP Layer Events
;
;	lap2lmpConnectIndication() call
;	lap2lmpDisconnectIndication()
;	lmp2lapDisconnectRequest()
;
;	lap2lmpRxData(w=Data)				;Incomming data bytes
;	lap2lmpRxValid() call				;Data bytes passed since RxFrame message are valid
;	lap2lmpRxError() call				;Data bytes passed since RxFrame message are invalid
;
;	lap2lmpTxFrame(ret z=None) call			;Lap layer can transmit a i-frame and will do so if z is returned false
;	lap2lmpTxData(ret w=Data ret z=Last) call	;Payload layer can accept a data byte (for an I frame) if there is one available. if there is data available then lmp returns data byte and sets z to false
;	lap2lmpTxValid() call				;Lap layer is indicating that all data passed since last TxStart message was acknowledged
;	lap2lmpTxError() call				;Lap layer is indicating that all data passed since last TxStart message will need to be sent again
;
;Application Events
;
;	app2lapDiscoveryRequest(ret z=Busy)		;Application wishes to initiate the XID discovery process
;	app2lapTxUIStart(ret z=Busy)			;Application wishes to send a UI command frame
;
;********************************************************************************
			ENDM


LapDataSeg		MACRO
;********************************************************************************
;  LAP LAYER
;********************************************************************************

		org	$70

lapBank		= 	$70				;8 bytes used

lapState	ds	1				;Current lap state
lapRxFrame	ds	1
lapRxData	ds	1
lapTxXIDSlot	ds	1

lapStatus	ds	1				;Status bits
lapRemoteBusy	=	lapStatus.0			;Remote busy flag
lapXIDDataFlag	=	lapStatus.1			;Indication that host has been informed that XID data will follow
lapRxUIDataFlag	=	lapStatus.2			;Indication that app layer has been informed that UI data will follow
lapTxUIDataFlag	=	lapStatus.3			;Indication that app layer has been informed that UI data will follow
lapLmpRxFlag	=	lapStatus.4			;Indication that lmp layer has sent data that has not been acknowledged
lapLmpTxFlag	=	lapStatus.5			;Indication that lmp layer has sent data that has not been acknowledged
lapMediaIdle	=	lapStatus.6			;Indication that the media has not been used in the past 500ms (NDM state only)

lapRxNs		ds	1				;%.....nnn = expected next I-frame sequence number (Ns)
lapRxNrAck	ds	1				;%.....nnn = expected next I-response sequence number if last frame that was transmitted has been acknowledged
lapRxNrNotAck	ds	1				;%.....nnn = expected next I-response sequence number if last frame that was transmitted has been not-acknowledged

lapNDMState		= 0				;NDM state
lapQUERYState		= 1				;QUERY state
lapNDM2NRMState		= 2				;internal state to wait for TxComplete so new connection parameters can be applied
lapNRMState		= 3				;NRM state
lapSCLOSEState		= 4				;SCLOSE state
lapSCLOSE2NDMState	= 5				;internal state to wait for TxComplete so default connection parameters can be applied

lapMaxFrameSize		= 64				;Max frame size = 64 bytes
lapMinTurnaround	= 116				;Number of additional BOFs to send @ 115200bps (116 = 10ms, 58 = 5ms)

Timer140ms		= -1				;1  =  1*256*256*108*(1/50MHz) =  141.56ms
Timer570ms		= -4				;4  =  4*256*256*108*(1/50MHz) =  566.23ms
Timer1000ms		= -7				;7  =  7*256*256*108*(1/50MHz) =  990.90ms
Timer3000ms		= -21				;21 = 21*256*256*108*(1/50MHz) = 2972.72ms
							;Note - For a different clock frequency the 108 ISR constant changes => these timeout numbers remain the same

;********************************************************************************
			ENDM


LapCodeSeg		MACRO
;********************************************************************************
;  LAP LAYER
;********************************************************************************

;********** a2lapReset **********

a2lapReset
	call	@lap2plGenerateNewAddr			;Generate new device address
	bank	lapBank
	mov	lapState, #lapNDMState			;Enter NDM state
	clr	lapStatus				;Init status
	jmp	lapMediaBusy				;Reset media idle detection (lapMediaBusy will issue retp instruction)

;********** a2lapTimer **********

a2lapTimer
	clrb	TimerOverflow				;Clear Timer flag
	bank	lapBank
	mov	w, lapState				;jump based on state
	jmp	PC+w
	jmp	lapNDMTimer				; 0 = lapNDMState
	jmp	lapQUERYTimer				; 1 = lapQUERYState
	retp						; 2 = lapNDM2NRMState
	jmp	lapNRMTimer				; 3 = lapNRMState
	jmp	lapSCLOSETimer				; 4 = lapSCLOSEState
	retp						; 5 = lapSCLOSE2NDMState

;********** pl2lapRxFrame **********

pl2lapRxFrame
	bank	lapBank
	mov	lapRxFrame, w				;Store frame type
	mov	w, lapState				;Jump based on state
	jmp	PC+w
	jmp	lapNDMRxFrame				; 0 = lapNDMState
	jmp	lapQUERYRxFrame				; 1 = lapQUERYState
	retp						; 2 = lapNDM2NRMState (RxFrame = impossable in this state)
	jmp	lapNRMRxFrame				; 3 = lapNRMState
	jmp	lapSCLOSERxFrame			; 4 = lapSCLOSEState
	retp						; 5 = lapSCLOSE2NDMState (RxFrame = impossable in this state)

;********** pl2lapRxValid **********

pl2lapRxValid
	bank	lapBank
	mov	w, lapState				;Jump based on state
	jmp	PC+w
	jmp	lapNDMRxValid				; 0 = lapNDMState
	jmp	lapQUERYRxValid				; 1 = lapQUERYState
	retp						; 2 = lapNDM2NRMState (RxValid is impossable in this state)
	jmp	lapNRMRxValid				; 3 = lapNRMState
	jmp	lapSCLOSERxValid			; 4 = lapSCLOSEState
	retp						; 5 = lapSCLOSE2NDMState (RxValid is impossable in this state)

;********** pl2lapRxValid - NRM State **********

lapNRMRxValid
	mov	w, lapRxFrame				;Jump based on frame type
	jmp	PC+w
	jmp	lapNRMXCmdValid				;xFrame		=	0
	jmp	lapNRMIValid				;iFrame		=	1
	jmp	lapNRMRRValid				;sRRFrame	=	2
	jmp	lapNRMRNRValid				;sRNRFrame	=	3
	jmp	lapNRMREJValid				;sREJFrame	=	4
	jmp	lapNRMSREJValid				;sSREJFrame	=	5
	jmp	lapNRMXCmdValid				;uUIFrame	=	6	;UICmd or UIRsp (same command)
	jmp	lapNRMDISCValid				;uDISCFrame	=	7	;DISCCmd or RDRsp (same command)
	jmp	lapNRMXCmdValid				;uUARspFrame	=	8	;UARsp
	jmp	lapNRMNRMValid				;uNRMFrame	=	9	;SNRMCmd or RNRMRsp (same command)
	jmp	lapNRMXCmdValid				;uTESTFrame	=	10	;TESTCmd or TESTRsp (same command)
	jmp	lapNRMXCmdValid				;uFRMRRspFrame	=	11	;FRMRRsp
	jmp	lapNRMXCmdValid				;uDMRspFrame	=	12	;DMRsp
	jmp	lapNRMXCmdValid				;uXIDCmdFrame	=	13	;XIDCmd
	jmp	lapNRMXCmdValid				;uXIDRspFrame	=	14	;XIDRsp

;********** pl2lapTxValid **********

pl2lapTxComplete
	bank	lapBank
	mov	w, lapState				;Jump based on state
	jmp	PC+w
	jmp	lapNDMTxComplete			; 0 = lapNDMState        (not interesting in TxComplete)
	retp						; 1 = lapQUERYState      (not interesting in TxComplete)
	jmp	lapNDM2NRMTxComplete			; 2 = lapNDM2NRMState    (now can apply connection parameters)
	retp						; 3 = lapNRMState        (not interesting in TxComplete)
	retp						; 4 = lapSCLOSEState     (not interesting in TxComplete)
	jmp	lapSCLOSE2NDMTxComplete			; 5 = lapSCLOSE2NDMState (now can apply defaultconnection parameters)

;********** fl2lapMediaBusy **********

fl2lapMediaBusy
	bank	lapBank
	cse	lapState, #lapNDMState			;NDM state ?
	retp						;No => ignore
	clrb	lapMediaIdle				;Clear MediaIdle flag
	test	lapRxFrame				;Is a frame being received ?
	sz
	retp						;Yes => do not reset timer
	mov	w, #Timer570ms				;No  => Reset timer to 500ms
	jmp	lapSetTimer				;Apply timer to wait for media idle

;********** DiscoveryRequest **********

app2lapDiscoveryRequest
	bank	lapBank
	cse	lapState, #lapNDMState			;NDM state ?
	clrb	lapMediaIdle				;No  => same as MediaIdle being false
	stz						;Indicate busy
	sb	lapMediaIdle				;Is the media idle ?
	retp						;No  => return busy indication
	bank	plBank
	mov	plConnAddr, #$FE			;Accept broadcast replys only
	bank	lapBank
	clr	lapTxXIDSlot				;Start at slot # 0
	mov	lapState, #lapQUERYState		;Enter QUERY state
	call	:Send					;Send first frame
	clz						;Indicate request was accepted
	retp
:Send	jmp	lapQUERYTimer

;********** DiscoveryRequest **********

app2lapTxUIStart
	bank	lapBank
	cse	lapState, #lapNDMState			;NDM state ?
	clrb	lapMediaIdle				;No  => same as MediaIdle being false
	stz						;Indicate busy
	sb	lapMediaIdle				;Is the media idle ?
	retp						;No  => return busy indication
	clrb	lapMediaIdle				;Remember that another frame cannot be sent
	setb	lapRxUIDataFlag				;Flag to pass messages to app layer
	call	@lap2plTxUICmd				;Request that the payload layer send a UI command frame
	clz						;Indicate request was accepted
	retp

;********************************************************************************
;  LAP LAYER - Internal Subroutines
;********************************************************************************

lapRandomFlags	=	Temp+0
lapRandomMask	=	Temp+1

;Slot bits: %00 =>  1 slot  => Mask = %0000 = 0 -> 0
;           %01 =>  6 slots => Mask = %0011 = 0 -> 3 (ie can't result in 4 or 5)
;           %10 =>  8 slots => Mask = %0111 = 0 -> 7
;           %11 => 16 slots => Mask = %1111 = 0 -> 15

lapRandomSlot						;returns Slot number to transmit in
	bank	plBank					;Peek at frame info
	mov	w, plXIDFlags				;get discovery flags
	bank	lapBank
	and	w, #%00000011				;Mask out non Slot bits
	snz						;Slot bits = 0 ?
	retp						;Yes => return 0
	mov	lapRandomFlags, w			;Store into Flags register
	mov	w, #%00000001				;If bit 1 = 0 then w = 0001
	snb	lapRandomFlags.1
	mov	w, #%00000111				;If bit 1 = 1 then w = 0111
	mov	lapRandomMask, w			;Mask = 0001 or 0111
	stc
	snb	lapRandomFlags.0			;If bit 0 = 1 then rotate left with carry set
	rl	lapRandomMask				;Rotate mask with carry set
	bank	TimerBank
	mov	w, Random				;random number (non resetable, increments every timer interrupt)
	bank	lapBank					;Note: The code is synchronous with RTCC and so RTCC is not a random number
	and	w, lapRandomMask			;Mask out unwanted bits
	mov	lapTxXIDSlot, w				;Store slot number
	retp

;********** SetTimer **********

lapSetTimer						;w = negative number to count up from
	bank	TimerBank				;-1 = 141.56ms
	clr	Timer1
	clr	Timer2
	mov	Timer3, w
	clrb	TimerOverflow
	bank	lapBank
	retp

;********** fl2lapMediaBusy **********

lapMediaBusy
	clr	lapRxFrame				;Reset frame type to none
	mov	w, #Timer570ms				;No  => Reset timer to 500ms
	jmp	lapSetTimer				;Apply timer to wait for media idle

;********************************************************************************
;  LAP LAYER
;********************************************************************************

;********** pl2lapRxError **********

pl2lapRxError
	bank	lapBank
	call	lapMediaBusy				;Reset media idle detection
	snb	laplmpRxFlag				;Has the lmp layer been receiving data ?
	jmp	:LMP					;Yes => must inform lmp layer
	snb	lapXIDDataFlag				;Has the host been informed to expect XID data ?
	jmp	:XID					;Yes => inform of error
	sb	lapRxUIDataFlag				;Is the app layer expecting data
	retp						;No  => return
:UI	clrb	lapRxUIDataFlag				;Yes => Inform app layer that UI frame is invalid
	jmp	@lap2appRxUIError
:LMP	clrb	laplmpRxFlag				;Clear flag
	jmp	@lap2lmpRxError				;Inform lmp layer of error (lmp layer will issue ret instruction)
:XID	clrb	lapXIDDataFlag				;Clear flag
	debugl	ShowXIDInfo, '}'			;Inform host of error
	retp


;********** pl2lapRxXIDData **********

pl2lapRxXIDData
	bank	lapBank
	sb	lapXIDDataFlag				;Is the host expecting XID Data ?
	retp						;No  => ignore data
	debug	ShowXIDInfo				;Yes => pass data
	retp

;********** pl2lapRxIData **********

pl2lapRxIData
	bank	lapBank
	sb	laplmpRxFlag				;Should we pass data ?
	retp						;No  => ignore data
	jmp	@lap2lmpRxData				;Yes => pass data

;********** pl2lapTxIData **********

pl2lapTxIData
	jmp	@lap2lmpTxData				;Get data from lmp layer

;********** pl2lapRxUIData **********

pl2lapRxUIData
	bank	lapBank
	sb	lapRxUIDataFlag				;Should we pass data ?
	retp						;No  => ignore data
	jmp	@lap2appRxUIData			;Yes => pass data

;********** pl2lapTxUIData **********

pl2lapTxUIData
	jmp	@lap2appTxUIData			;Get data from app layer

;********************************************************************************
;  LAP LAYER - NDM Events
;********************************************************************************

lapEnterNDMState					;Reset connection parameters
	mov	lapState, #lapNDMState			;Enter NDM state
	call	lapMediaBusy				;Reset media idle detection
:Tx	sb	laplmpTxFlag				;Is the lmp data waiting for comformation of data ?
	jmp	:Rx					;No  => contiue without message to lmp layer
	clrb	laplmpTxFlag				;Yes => inform lap layer that data was not-acknowledged and contiue
	call	@lap2lmpTxError
	bank	lapBank
:Rx	sb	lapLmpRxFlag				;Is the lmp layer expecting data ?
	jmp	:Cont					;No  => contiue without message to lmp layer
	clrb	lapLmpRxFlag				;Yes => must inform lmp layer that data is invalid
	call	@lap2lmpRxError
:Cont	bank	plBank
	mov	plConnAddr, #$FF			;Not connected => set ConnAddr to only accept be $FF
	bank	flBank
	mov	flFFCount, #10				;Default to 10 FFs @ 9600 = 10.42ms
	bank	IsrBank
	mov	IrdaSpeed, #Irda9600			;IrDA UART speed = 9600
	clrb	ledCON					;Turn off Connect LED
	debugl	ShowConnect, ']'
	jmp	@lap2lmpDisconnectIndication		;Inform lmp layer of disconnection

;********** NDM - RxFrame **********

lapNDMRxFrame
	csne	lapRxFrame, #uXIDCmdFrame		;XID Command frame ?
	jmp	:Accept					;Yes => Accept frame (may want to code to inform host of incommming XIDCmd frame ?)
	csne	lapRxFrame, #uNRMFrame			;SNRM Command frame ?
	jmp	:Accept					;Yes => Accept frame
	csne	lapRxFrame, #uUIFrame			;UI frame ?
	jmp	:UI					;Yes => Accept frame
	clr	lapRxFrame				;No  => Ignore frame
	jmp	@lap2plRxIgnore				;Request that the payload layer ignores the frame
:UI	setb	lapRxUIDataFlag				;Flag to pass data to app layer
:Accept	mov	w, #Timer570ms				;500ms Timeout
	jmp	lapSetTimer				;(lapSetTimer will issue retp instruction)

;********** NDM - Timer **********

lapNDMTimer
	test	lapRxFrame				;Was a frame being received ?
	jnz	pl2lapRxError				;Yes => treat as error, pl2lapRxError will reset the MediaBusy detection
	setb	lapMediaIdle				;No  => media must be idle
	retp

;********** NDM - RxValid **********

lapNDMRxValid
	csne	lapRxFrame, #uXIDCmdFrame		;XID Command frame ?
	jmp	:XID					;Yes => process
	csne	lapRxFrame, #uNRMFrame			;SNRM Command frame ?
	jmp	:SNRM					;Yes => process
							;No  => must be UI frame
:UI	call	lapMediaBusy				;Reset media idle detection
	sb	lapRxUIDataFlag				;Is the app layer expecting data
	retp						;No =>  ignore
	clrb	lapRxUIDataFlag				;Yes => Inform app layer that UI frame is complete
	jmp	@lap2appRxUIValid

:XID	call	lapMediaBusy				;Reset media idle detection
	bank	plBank					;Peek at frame info
	snb	plXIDFlags.2				;Is the "Generate new device address" flag set ?
	call	@lap2plGenerateNewAddr			;Yes => ask payload layer to generate a new 32-bit address
	bank	plBank					;Peek at frame info
	test	plXIDSlot				;is the slot number = 0 ?
	bank	lapBank
	snz
	call	lapRandomSlot				;Yes => generate random slot (slot returned in lapTxXIDSlot)
	mov	w, lapTxXIDSlot				;Get the slot number to transmit in
	bank	plBank
	mov	w, plXIDSlot-w				;Subtract (ie compare) with current slot number
	sz						;Are they the same ? (ie this slot to transmit in ?)
	retp						;No  => return
	bank	lapBank
	mov	w, lapTxXIDSlot
	clr	lapTxXIDSlot				;Reset slot number to indicate that a reply has been sent
	jmp	@lap2plTxXIDRsp				;Transmit response

:SNRM	mov	lapState, #lapNDM2NRMState		;Next state wil be NDM2NRM state to apply connection parameters after this reply has been sent
	clrb	lapRemoteBusy				;Initilise RemoteBusy flag to false
	clr	lapRxNs					;Initilise RxNs to 0
	clr	lapRxNrAck				;Initilise RxNrAck to zero
	clr	lapRxNrNotAck				;Initilise RxNrNotAck to zero
	mov	w, #Timer1000ms				;1s timeout IrDA Lite p15)
	call	lapSetTimer
	setb	ledCON					;Turn on Connect LED
	debugl	ShowConnect, '['
	call	@lap2lmpConnectIndication		;Inform lmp layer of connection
	jmp	@lap2plSNRMAccept			;Send reply

;********** NDM - TxComplete **********

lapNDMTxComplete
	call	lapMediaBusy				;Reset media idle test
	sb	lapRxUIDataFlag				;Is the app layer expecting data
	retp						;No =>  ignore
	clrb	lapRxUIDataFlag				;Yes => Inform app layer that UI frame is complete
	jmp	@lap2appTxUIComplete

;********************************************************************************
;  LAP LAYER - QUERY Events
;********************************************************************************

;********** QUERY - RxFrame **********

lapQUERYRxFrame
	cse	lapRxFrame, #uXIDRspFrame		;XID Response frame ?
	jmp	@lap2plRxIgnore				;No  => Ignore frame
	setb	lapXIDDataFlag				;Yes => Accept frame. Remember that currently passing data to host
	debugl	ShowXIDInfo, '{'			;Show XID info start
	retp

;********** QUERY - RxValid **********

lapQUERYRxValid
	sb	lapXIDDataFlag				;Is the host expecting data
	retp						;No =>  ignore
	clrb	lapXIDDataFlag				;Yes => Inform host that XID frame is complete
	debugl	ShowXIDInfo, '}'
	retp

;********** QUERY - Timer **********

lapQUERYTimer
	bank	TimerBank				;Set global timer
	clr	Timer1					;80ms timeout after transmission is complete (75-85ms IrDA Lite p21)
	mov	Timer2, #-198				;80ms timeout + 29.2 ms (28 bytes) to transmit = 109.2ms. 198 : 198*256*108*(1/50MHz) = 109.49ms
	mov	Timer3, #-1				;negitive number
	clrb	TimerOverflow
	bank	lapBank
	sb	lapXIDDataFlag				;Has the host been informed to expect XID data ?
	jmp	:Good					;Yes => inform of error
	clrb	lapXIDDataFlag				;Clear flag
	debugl	ShowXIDInfo, '}'			;Inform host of error
:Good	cse	lapTxXIDSlot, #08			;Last slot ?
	jmp	:Send					;No  => send
	mov	lapState, #lapNDMState			;Yes => After send will return to NDM state
	mov	w, #$FF					;w = FF
	mov	lapTxXIDSlot, w				;set slot to $FF to indicate complete
	bank	plBank
	mov	plConnAddr, w				;ConnAddr = FF => Accept broadcast commands only
	bank	lapBank
:Send	mov	w, lapTxXIDSlot				;Get current slot #
	inc	lapTxXIDSlot				;Increment for nexty slot #
	jmp	@lap2plTxXIDCmd				;Send XID command frame (payload layer will return)

;********************************************************************************
;  LAP LAYER - NRM Events
;********************************************************************************

;********** NDM2NRM - TxComplete **********

lapNDM2NRMTxComplete
	mov	lapState, #lapNRMState			;NRM state
	bank	plBank					;Agreed BaudRate is the most significant bit that is set in plSNRMBaudRate
	mov	w, #Irda9600				;Min = 9600
	snb	plSNRMBaudRate.2			;19200 ?
	mov	w, #Irda19200				;Yes => w = 19200
	snb	plSNRMBaudRate.3			;38400 ?
	mov	w, #Irda38400				;Yes => w = 38400
	snb	plSNRMBaudRate.4			;57600 ?
	mov	w, #Irda57600				;Yes => w = 57600
	snb	plSNRMBaudRate.5			;115200 ?
	mov	w, #Irda115200				;Yes => w = 115200
	bank	IsrBank
	mov	IrdaSpeed, w				;Apply baud rate
	bank	plBank					;Set FF Count to ensure 10ms. FFCount = BaudRate / 10 * 0.01s
	mov	w, #lapMinTurnaround / 11.6		;Min = 9600 => 10ms = 10 bytes
	snb	plSNRMBaudRate.2			;19200 ?
	mov	w, #lapMinTurnaround / 5.8		;Yes => 10ms = 20 bytes
	snb	plSNRMBaudRate.3			;38400 ?
	mov	w, #lapMinTurnaround / 2.9		;Yes => 10ms = 39 bytes
	snb	plSNRMBaudRate.4			;57600 ?
	mov	w, #lapMinTurnaround / 2		;Yes => 10ms = 58 bytes
	snb	plSNRMBaudRate.5			;115200 ?
	mov	w, #lapMinTurnaround			;Yes => 10ms = 116 bytes
	bank	flBank
	mov	flFFCount, w				;Apply FFCount
	retp

;********** NRM - SendResponse **********

lapSendNRMResponse
	snb	lapRemoteBusy				;Is the remote busy flag set ?
	jmp	lapSendSResponse			;Yes => send S-Response
	call	@lap2lmpTxFrame				;Returns z = false if data to be sent
	bank	lapBank
	snz						;Is there data to be sent ?
	jmp	lapSendSResponse			;No  => send S-Response
:Data	setb	laplmpTxFlag				;Yes => Rember that lmp layer is passing data
	mov	w, <<lapRxNs				;Send Nr = RxNs. w = RxNs %....nnn.
	and	w, #%00001110				;mask out non Ns bits
	mov	Temp, w					;Store in Temp
	swap	Temp					;Temp = RxNs %nnn.....
	setb	Temp.4					;Set bit 4 = final flag
	mov	w, <<lapRxNrAck				;Send Ns = RxNrAck. w = RxNrAck %....nnn.
	and	w, #%00001110				;mask out non Ns bits
	add	w, Temp					;Add Nr bits
	inc	lapRxNrAck				;add 1 to NrAck - the expect acknowledge
	jmp	@lap2plTxIRsp				;Transmit I frame
	
lapSendSResponse
	mov	w, <<lapRxNs				;Send Nr = RxNs. w = RxNs %....nnn.
	and	w, #%00001110				;mask out non Ns bits
	mov	Temp, w					;Store in Temp
	swap	Temp					;Temp = RxNs %nnn.....
	mov	w, #sRR					;frame will be of type RR
	add	w, Temp					;Set Nr of frame to RxNs = expected next I frame
	jmp	@lap2plTxSimpleRsp			;Send simple response frame

;********** NRM - SendRD **********

lapNRMSendRD
	mov	w, #Timer3000ms
	call	lapSetTimer				;Reset timer for SCLOSE state
	sb	lapLmpRxFlag				;Is the lmp layer expecting data ? (ie error caused by timeout)
	jmp	:Cont					;No  => contiue
	clrb	lapLmpRxFlag				;Yes => must inform lmp layer that data is invalid
	call	@lap2lmpRxError				;
	bank	lapBank
:Cont	mov	lapState, #lapSCLOSEState		;change to SCLOSE state
	mov	w, #uRDRsp				;frame will be of type RD
	jmp	@lap2plTxSimpleRsp			;Send simple response frame

;********** NRM - RxFrame **********

lapNRMRxFrame
	csne	lapRxFrame, #iFrame			;I Data frame ?
	setb	lapLmpRxFlag				;Yes => Flag to pass data to lmp layer
	retp						;Accept all frames

;********** NRM - SValid or IValid **********

lapNRMSIValid
	mov	w, #Timer3000ms
	call	lapSetTimer				;Reset timer on any S-Command
	bank	plBank
	mov	w, >>plCommand				;w = %.nnn.... get the received command byte (shifted)
	mov	Temp, w					;Temp = received Nr bits (%.nnn....)
	swap	Temp					;Temp = received Nr bits (%.....nnn)
	bank	lapBank
	mov	w, lapRxNrAck				;w = expected Nr if Ack
	xor	w, Temp					;compare received Nr with NrAck
	and	w, #%00000111				;only examine lowest bits
	snz						;Does Nr = NrAck (ie is this a valid ack) ?
	jmp	:Ack					;Yes => valid Ack
	mov	w, lapRxNrNotAck			;w = expected Nr if Not-Ack
	xor	w, Temp					;compare received Nr with NrNotAck
	and	w, #%00000111				;only examine lostest bits
	sz						;Does Nr = NrNotAck (ie is this a valid not-ack) ?
	jmp	lapNRMSendRD				;No  => Fatal Error - invalid Nr => must disconnect (Valid/Error message for LMP layer willbe sent prior to the DisconnectIndication)
:NotAck	dec	lapRxNrAck				;return NrAck back to what it was before transmission of the last I-Frame
	sb	laplmpTxFlag				;Is the lmp data waiting for comformation of data ?
	jmp	:Cont					;No  => contiue without message to lmp layer
	clrb	laplmpTxFlag				;Yes => inform lap layer that data was not-acknowledged and contiue
	call	@lap2lmpTxError
	jmp	:Cont
:Ack	mov	lapRxNrNotAck, lapRxNrAck		;Set NrNotAck to match NrAck
	sb	laplmpTxFlag				;Is the lmp data waiting for comformation of data ?
	jmp	:Cont					;No  => contiue without message to lmp layer
	clrb	laplmpTxFlag				;Yes => inform lap layer that data was acknowledged and contiue
	call	@lap2lmpTxValid
:Cont	bank	lapBank
	cse	lapRxFrame, #iFrame			;Is this an i frame ?
	jmp	lapSendNRMResponse			;No  => S frame => Send-NRM-Response
	bank	plBank					;Yes => must test Ns
	mov	w, >>plCommand				;get the received command byte (shifted right 1 bit)
	bank	lapBank
	xor	w, lapRxNs				;Compare with expected Ns
	and	w, #%00000111				;Only test lowest 3 bits
	jnz	:Ignore					;If Ns <> expected then ignore
:Valid	inc	lapRxNs					;increment RxNs
	sb	lapLmpRxFlag				;Is the lmp layer expecting data ?
	jmp	lapSendNRMResponse			;No  => send NRM-response
	clrb	lapLmpRxFlag				;Yes => must inform lmp layer that data is complete
	call	@lap2lmpRxValid				;Indicate data complete and valid
	bank	lapBank
	jmp	lapSendNRMResponse			;send NRM-response
:Ignore	sb	lapLmpRxFlag				;Is the lmp layer expecting data ?
	jmp	lapSendSResponse			;No  => send S-response
	clrb	lapLmpRxFlag				;Yes => must inform lmp layer that data is invalid
	call	@lap2lmpRxError				;
	bank	lapBank
	jmp	lapSendSResponse			;send S-response

lapNRMIValid	=	lapNRMSIValid			;A I frame has been received

lapNRMRRValid						;A RR frame has been received
	clrb	lapRemoteBusy				;Remember that remote is not busy and send reply
	jmp	lapNRMSIValid

lapNRMRNRValid						;A RNR frame has been received
	setb	lapRemoteBusy				;Remember that remote is busy and send reply
	jmp	lapNRMSIValid

lapNRMREJValid	=	lapNRMSIValid		;A REJ frame has been received
lapNRMSREJValid	=	lapNRMSIValid		;A SREJ frame has been received

;********** NRM - SNRMCmdValid **********

lapNRMNRMValid	=	lapNRMSendRD

;********** NRM - XCmdValid **********

lapNRMXCmdValid	=	lapSendSResponse

;********** NRM - DISCCmdValid **********

lapNRMDISCValid						;Disconnect command: ack and apply default parameters.
	mov	lapState, #lapSCLOSE2NDMState		;Next state = transition to apply origional connection parameters once this frame has been sent
	mov	w, #uUARsp				;Send UA frame to acknowledge disconnect
	jmp	@lap2plTxSimpleRsp			;Send simple response frame

;********** NRM - Timer **********

lapNRMTimer	=	lapEnterNDMState		;Timeout => return to NDM state.

;********** lmp2lapDisconnectRequestr **********

lmp2lapDisconnectRequest
	bank	lapBank
	cse	lapState, #lapNRMState			;Currenly in NRM state ?
	retp						;No  => ignore request
	mov	lapState, #lapSCLOSEState		;Yes => change to SCLOSE state
	retp

;********************************************************************************
;  LAP LAYER - NRM Events
;********************************************************************************

;********** SCLOSE - RxFrame **********

lapSCLOSERxFrame
	retp						;Accept all frames

;********** SCLOSE - RxValid **********

lapSCLOSERxValid
	csne	lapRxFrame, #uDISCFrame			;DISC Command frame ?
	jmp	lapNRMDISCValid				;Yes => Send ack, apply default parameters and enter NDM state
	mov	w, #Timer3000ms
	call	lapSetTimer				;No, however still must be a command frame (due to ConnAddr) => send RD frame
	mov	w, #uRDRsp				;Send RD Response frame to request disconnect
	jmp	@lap2plTxSimpleRsp			;Send simple response frame

;********** SCLOSE - Timer **********

lapSCLOSETimer		=	lapEnterNDMState

;********** SCLOSE2NDM - TxComplete **********

lapSCLOSE2NDMTxComplete	=	lapEnterNDMState

;********************************************************************************
		ENDM



file: /Techref/scenix/lib/io/osi2/ir/da/LAP.SRC, 27KB, , updated: 1999/8/20 19:47, local time: 2017/10/17 14:05,
TOP NEW HELP FIND: 
54.166.203.76:LOG IN

 ©2017 These pages are served without commercial sponsorship. (No popup ads, etc...).Bandwidth abuse increases hosting cost forcing sponsorship or shutdown. This server aggressively defends against automated copying for any reason including offline viewing, duplication, etc... Please respect this requirement and DO NOT RIP THIS SITE. Questions?
Please DO link to this page! Digg it! / MAKE! / 

<A HREF="http://www.piclist.com/techref/scenix/lib/io/osi2/ir/da/LAP.SRC"> scenix lib io osi2 ir da LAP</A>

Did you find what you needed?

  PICList 2017 contributors:
o List host: MIT, Site host massmind.org, Top posters @20171017 RussellMc, Van Horn, David, James Cameron, Sean Breheny, IVP, alan.b.pearce, Neil, David C Brown, Bob Blick, Denny Esterline,
* Page Editors: James Newton, David Cary, and YOU!
* Roman Black of Black Robotics donates from sales of Linistep stepper controller kits.
* Ashley Roll of Digital Nemesis donates from sales of RCL-1 RS232 to TTL converters.
* Monthly Subscribers: Gregg Rew. on-going support is MOST appreciated!
* Contributors: Richard Seriani, Sr.
 

Welcome to www.piclist.com!

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

  .