sam2t.src.bak

用SAM72N9写的电子秤文档

MainCalculate26
;----------------------------------------------------------
MainCalculate29
	REF	RCalWeightCnt	;
;=====================================
MainCalculate2
	BITR	OvrWtNow	;
	CALLS	ChkOverloading	; Chk overload
	JR	MainCalculate3	;
	BITS	OvrWtNow	;
	CALLS	OverloadingProc	;
	RET			;

MainCalculate3
	BTSF	HoldRd		; check reading is hold now
	RET

	BITR	UdrWtNow	;
	CALLS	ChkUnderweight	; Chk underweight
	JR	MainCalculate6	;
	BITS	UdrWtNow	;
	CALLS	UnderweightProc	;
	BTST	UdrWtNow	;
	JR	MainCalculate7	;
	RET			;

MainCalculate6
	BITR	UdrWtNow	; Clear UdrWtNow
	BITR	OvrWtNow	; Clear OvrWtNow
	BITR	AutoZeroNow	; Disable Reset to Zero
	LD	A,#BCNT2s_RL	;
	LD	AutoZeroTim,A	; reload Auto zero timer

MainCalculate7
	BTST	SolLiqMode	; if Solid mode,
	JR	MainCalculate8	; jump
	BTST	UnitMode	;
	JPS	CalculateML	;
	JPS	CalculateFLOZ	; Remark for temporary Creep testing
MainCalculate8
	BTST	UnitMode	;
	JPS	CalculateKG	;
	JPS	CalculateLB	; Remark for temporary Creep testing

;***********************************************************
;	F: Calculate NewWeightCnt
;	I: AverageCount, ZeroCount
;	O: NewWeightCnt
CalWeightCount
	PUSH	EA
	PUSH	HL
	PUSH	WX

	LD	HL,#ZeroCount		;
	LD	WX,#AverageCount	;
	REF	RCmpHex			; if @HL <= @WX, skip
	JR	CalWeightCnt2		;

	; NewWeightCnt = AverageCount - ZeroCount
	LD	HL,#ZeroCount
	LD	WX,#AverageCount
	REF	RSubHex			; HexBuf = @WX - @HL
	LD	EA,HexBuf+2
	LD	NewWeightCnt+2,EA
	LD	EA,HexBuf
	LD	NewWeightCnt,EA
	JR	CalWeightCntE

CalWeightCnt2
	REF	RLD_EA0			;
	LD	NewWeightCnt,EA		; MSB
	LD	NewWeightCnt+2,EA	; LSB

CalWeightCntE
	REF	RRET_WXHLEA

;***********************************************************
;	F: Take Average of 2 Samples Count
;	I: SampleCount0, SampleCount1
;       O: YZ = MSB; WX = LSB
;	   AverageCount
;	D: EA, HL, WX, YZ
;
AverageSample
	BITS	PermitUpdate	; Not permit update sample
GetSample0
	LD	EA,SampleCount0	;
	LD	YZ,EA		; Sample 0 MSB
	LD	EA,SampleCount0+2;
	REF	RLD_WXEA	; Sample 0 LSB
GetSample1
	LD	EA,SampleCount1	;  Sample 1 MSB
	REF	RLD_HLEA	;
	LD	EA,SampleCount1+2; Sample 1 LSB

	BITR	PermitUpdate	; Permit update sample

	RCF			;
	ADC	WX,EA		; WX = Sum of LSB
	LD	EA,HL		;
	ADC	YZ,EA		; YZ = Sum of MSB
	CALL	SRC_YZWX	; Shift YZWX Right 1-bit

	LD	EA,YZ		; MSB
	LD	AverageCount,EA	;
	LD	EA,WX		; LSB
	LD	AverageCount+2,EA

	LD	A,#0		;
	LD	HaveData,A	;

	BTST	CalibrateOn	; if not Calibration Mode,
	RET			; exit

	BTSF	CaliMethod	; if not Calibration Method 1
	RET			; exit
;-----
	LD	EA,#((HiVoltBnd/256)-1)
	SBS	EA,YZ		; Chk MSB
	JR	ChkHiLoBnd3	;
	REF	RLD_HLEA	;
	INCS	HL		; if MSB = HiVoltBnd/256,
	JR	ChkHiLoBnd2	; chk LSB
	LD	EA,#(HiVoltBnd%256)
	SBS	EA,WX		;
	JR	ChkHiLoBnd3	;
ChkHiLoBnd2
	BITS	OvrHiVoltNow	; Exact Hi-Volt Boundary
	RET			; exit
ChkHiLoBnd3
	BITR	OvrHiVoltNow	; Not Exact Hi-Volt Boundary
;-----
	LD	EA,#((LoVoltBnd/256)+1)
	SBS	YZ,EA		; Chk MSB
	JR	ChkHiLoBnd6     ;
	INCS	YZ		; if MSB = LoVoltBnd/256,
	JR	ChkHiLoBnd5	; chk LSB
	LD	EA,#(LoVoltBnd%256)
	SBS	WX,EA		;
	JR	ChkHiLoBnd6	;
ChkHiLoBnd5
	BITS	BlwLoVoltNow	; Below Lo-Volt Boundary
	RET			; exit
ChkHiLoBnd6
	BITR	BlwLoVoltNow	; Not Below Lo-Volt Boundary
	RET			; exit


;====== SELF TEST ROUTINE ==========================================

;***********************************************************
;	F: Sub function of RAM test routine
;	I: EMB, SMB
;	   HL = Start Address
;	   WX = Test Value
;	   YZ = End Address(this addr will not be tested)
;	D: HL, EA
;
RAMTST1	LD	EA,WX		;
	XCH	EA,@HL		;
	XCH	EA,@HL		;
	CPSE	EA,WX		;
	JPS	RAMTST_ERR	;
	INCS	HL		;
	NOP			;
	LD	EA,YZ		;
	REF	RCPSE_EAHL	;
	JR	RAMTST1		;
	RET			;

;*******************************
;	F: RAM Test Routine
;	   (Bank 0 - 008..0ffh, Bank 1 - 1e0h..1f7h)
;
RAMTEST	SMB	StackBank	; Select Stack Memory Bank
	LD	WX,#55h		; Test w/ 055h value
	LD	YZ,#00h		;
RAMTST2	LD	HL,#08		; Range 008h .. 0ffh
	CALL	RAMTST1		;
	CPSE	W,#05h		;
	JR	RAMTST5		;
	LD	WX,#0aah	; Test w/ 0aah value
	JR	RAMTST2		;

RAMTST5	REF	RSMB_LCD 	; Select LCD Memory Bank
	LD	WX,#55h		; Test w/ 055h value
	LD	YZ,#0f8h	;
RAMTST6	LD	HL,#0e0h	; Range 0e0h .. 0f7h
	CALL	RAMTST1		;
	CPSE	W,#05h		;
	JR	RAMTST8		;
	LD	WX,#0aah	; Test w/ 0aah value
	JR	RAMTST6		;

RAMTST8	REF	RSMB_Variable	;
	JPS	Reset_2		;

RAMTST_ERR
	JPS	Sleep2		;

;***********************************************************
;	F: Return Current dsp step count array (multiplied by 10)
;	I: NewWeightCnt, Bound1, Step1, Step2
;	   WX = Array lsb pointer
;	O: @WX
CurStep2Ary
	PUSH	EA
	PUSH	HL
	PUSH	WX

	LD	HL,#Step1+2	;
	REF	RWrd2Ary	;

	REF	RRET_WXHLEA

;***********************************************************
;	F: Return Actual current dsp step count array
;	I: NewWeightCnt, Bound1, Step1, Step2
;	O: YS_F_REG[]
;	N: if NewWeightCnt >= Bound1, return Step2, otherwise Step1
ActlCurStep2Ary
	LD	WX,#YS_F_REG_4	;
	REF	RCurStep2Ary	;
	REF	RDiv_10_FReg	;

	LD	A,YS_R_REG_4	;
	REF	RCPSE_A0	;
	JR	ActlCurStep2Ary2;
	RET
ActlCurStep2Ary2
	LD	A,#1		;
	LD	HL,#YS_F_REG_4	;
	CALLS	AddByLSB	;
	RET

;***********************************************************
;	F: Set Lower & Upper Boundary
;	I: ZeroCount, UnitMode, Bound2, Unitcnt
;	O: ZeroBound, MaxBound
;	D: EA, HL, WX, YZ
;
SetBnd
	LD	A,FactoryMode		;
	ADS	A,#12			; if mode 5..7,
	JR	StB5_8			;
	ADS	A,#15			; if mode 4,
	JR	StB4			;
	JPS	StB1_3			; if mode 1..3,

StB5_8	LD	EA,#ZeroBndWidth5_8	;
StB4	LD	EA,#ZeroBndWidth4	;
StB1_3	LD	EA,#ZeroBndWidth1_3	;
	LD	YZ,EA

	RCF			;
	LD	EA,ZeroCount+2	; LSB
	SBC	EA,YZ		;
	LD	ZeroBound+2,EA	; ZeroBound = ZeroCount - 30
	LD	YZ,#0		; Clear MSB
 	LD	EA,ZeroCount	; MSB
	SBC	EA,YZ		;
	LD	ZeroBound,EA	;
	RET

;***********************************************************
;	F: Get the current average count
;	I: AverageCount, @HL
;	O: @HL
;	D: EA, HL
;
GetAverageCnt
	LD	EA,AverageCount
	LD	@HL,EA
	REF	RINCS_2HL
	LD	EA,AverageCount+2
	LD	@HL,EA
	RET


;====== MISCELLANY ROUTINE =========================================

;***********************************************************
ozRatio2LReg
	LD	A,ozRatio+2	; LD ozRatio to YS_L_REG[]
	LD	YS_L_REG_4,A	; LSB
	LD	A,ozRatio+3	;
	LD	YS_L_REG_3,A	;
	LD	A,ozRatio+0	;
	LD	YS_L_REG_2,A	;
	LD	A,ozRatio+1	;
	LD	YS_L_REG_1,A	;
	LD	A,#0		;
	LD	YS_L_REG_0,A	; MSB
	RET

;---------------------------------
lbRatio2LReg
	LD	A,lbRatio+2	; LD lbRatio to YS_L_REG[]
	LD	YS_L_REG_4,A	; LSB
	LD	A,lbRatio+3	;
	LD	YS_L_REG_3,A	;
	LD	A,lbRatio+0	;
	LD	YS_L_REG_2,A	;
	LD	A,lbRatio+1	;
	LD	YS_L_REG_1,A	; MSB
	LD	A,#0		;
	LD	YS_L_REG_0,A	;
	RET

;---------------------------------
;	F: Convert NewWeightCnt binary to YS_F_REG[] hex digit array
;	I: NewWeightCnt
;	O: YS_F_REG[]
;	D: HL, WX
;
NWCnt2FReg
	LD	HL,#NewWeightCnt+2
	LD	WX,#YS_F_REG_4	; YS_F_REG = NewWeightCnt / oz Count * 10
	REF	RWrd2Ary	;
	RET

;---------------------------------
;	F: Convert YS_F_REG[] hex value to DecBuf[] dec value
;	I: YS_F_REG[]
;	O: DecBuf[]
;	D: HL, WX
;
HxFReg2Dec
	LD	WX,#YS_F_REG_4	; Copy YS_F_REG[] to HexBuf[]
	LD	HL,#HexBuf3	;
	CALL	CpyBuf2		;
	REF	RHex2BCD_16	; Convert Hex result to Dec
	RET

;---------------------------------
;	F: Copy YS_R_REG[] to YS_F_REG[]
;	I: YS_R_REG[]
;	O: YS_F_REG[]
;	D: HL, WX
;
Cpy_R2FReg
	LD	WX,#YS_R_REG_4	; Copy YS_R_REG[] to YS_F_REG[]
	JR	CpyReg2		;

;---------------------------------
;	F: Copy YS_F_REG[] to YS_L_REG[]
;	I: YS_R_REG[]
;	O: YS_F_REG[]
;	D: HL, WX
;
Cpy_F2LReg
	LD	WX,#YS_F_REG_4	; Copy YS_F_REG[] to YS_L_REG[]
CpyReg1	LD	HL,#YS_L_REG_4	;
CpyReg2	LD	HL,#YS_F_REG_4	;
	REF	RCpyBuf		;
	RET

;***********************************************************
;	F: Hex(16-bit) to BCD Format(5-digit) (MAX = 65535)
;	I: HexBuf[] = Hex Number(Max 4 digit)
;       O: DecBuf[] = Dec Number(Max 5 digit)
;
Hex2BCD_16
	PUSH	EA
	PUSH	HL

	LD	HL,#DecBuf4	;
HexBCD1	LD	A,#0		; Clear DecBuf[]
	XCHD	A,@HL		;
	JR	HexBCD1		;

	LD	Y,#15		; Loop 16-bits
HexBCD3	RCF			; C <-- 0
	LD	HL,#HexBuf3	;
HexBCD5	LD	A,@HL		;
	ADC	A,@HL		; Shift left by 1 bit
	XCHD	A,@HL		;
	JR	HexBCD5		;

	LD	HL,#DecBuf4	;
HexBCD7	LD	A,#6            ; Decimal adjustment
	ADS	A,@HL		;
	ADC	A,@HL		;
	ADS	A,#10		;
	XCHD	A,@HL		;
	JR	HexBCD7		;

	DECS	Y		; Is it over ?
	JPS	HexBCD3		; NO,Jump HexBCD3
	REF	RRET_HLEA	; YES,Return

;***********************************************************
;	F: Copy Buf to Buf from @WX to @HL
;	I: HL = Destination Buf(Buf end pointer)
;	   WX = Source Buf(Buf end pointer)
;	O: HL = Duplicated Buf
;	D: A, HL, W
;
CpyBuf2	INCS	X		;
CpyBf1	DECS	X		;
	JR	CpyBf2		;
	RET			;
CpyBf2	LD	A,@WX		;
	XCHD	A,@HL		;
	JR	CpyBf1		;
	RET

;***********************************************************
;	F: Copy a byte to a digit array
;	I: EA = byte data
;	   HL = digit array lsb pointer
;	O: @HL
;	D: A, L
;
ByteAry	XCHD	A,@HL		;
	LD	A,E		;
	XCHD	A,@HL		;
BytAry1	LD	A,#0		;
	XCHD	A,@HL		;
	JR	BytAry1		;
	RET

;***********************************************************
;	F: Copy 16-bit word to 4-digit array OR
;	I: HL = Source (lsb 8-bit pointer)
;	   WX = Destination (End buf pointer)
;	O: WX = Result
;	D: EA, HL, WX
;
Wrd2Ary	PUSH	YZ
	LD	Y,#1		;
Wd2Ay1	LD	EA,@HL		;
	XCH	A,@WX		;
	DECS	WX		;
	LD	A,E		;
	XCH	A,@WX		;
	DECS	WX		;
	REF	RDECS_HL	;
	REF	RDECS_HL	;
	NOP			;
	DECS	Y		;
	JR	Wd2Ay1		;
	POP	YZ
	RET

;***********************************************************
;	F: Compare 2 Array with 5 digits
;	I: HL = 1st Array MSB pointer
;	   WL = 2nd Array MSB pointer
;	O: @WL <  @HL, skip return
;	   @WL >= @HL, return
;	D: A, Y, HL
;
CmpDig	LD	Y,#4		; 5 Digits
CmpDig1	LD	A,@WL		;
	SBS	A,@HL		; IF @WL < @HL, Skip return
	JR	CmpDig2		;
	SRET			;
CmpDig2	DECS	A		;
	RET			;
	INCS	L		;
	DECS	Y		;
	JR	CmpDig1		;
	RET			;

;***********************************************************
;	F: Multiple YS_F_REG[] with 10
;	I: YS_F_REG[]
;	O: YS_F_REG[]
;	D: EA, HL
;
Mul_10_FReg
	LD	EA,#10		;
Mul_EA_FReg
	LD	HL,#YS_L_REG_4	;
	REF	RByteAry	;
	CALLS	Mul_YS		;
	REF	RCpy_R2FReg	;
	RET

;***********************************************************
;	F: Divide YS_F_REG[] with 10
;	I: YS_F_REG[]
;	O: YS_F_REG[], YS_R_REG[]
;	D: EA, HL
;
Div_10_FReg
	LD	EA,#10		;
Div_EA_FReg
	LD	HL,#YS_L_REG_4	;
	REF	RByteAry	;
	REF	RDiv_YS		;
	RET

;***********************************************************
;	F: Compare 16-bit Hexadecimal Data
;	I: HL = 1st Data Start Pointer(msb)
;	   WX = 2nd Data Start Pointer(msb)
;	O: skip return if @HL <= @WX
;	   return if @HL > @WX
;
CmpHex	PUSH	EA
	PUSH	HL
	PUSH	WX
	PUSH	YZ

	PUSH	HL
	LD	EA,WX
	REF     RLD_HLEA

	LD	EA,@HL
	REF	RLD_WXEA	; WX = msb of 2nd Data
	REF	RINCS_2HL
	LD	EA,@HL
	LD	YZ,EA		; YZ = lsb of 2nd Data
	POP	HL

	LD	EA,@HL		; Load msb of 1st Data
	SBS	EA,WX		; @HL(msb) < @WX(msb), skip
	JR	CmpHex1		;
	JR	CmpHex4		;

CmpHex1	DECS	EA		; if @HL(msb)=@WX(msb), skip
	JR	CmpHex6		;
	REF	RINCS_2HL	;
	LD	EA,@HL		;
	CPSE	EA,YZ		; @HL(lsb) = @WX(lsb), skip
	JR	CmpHex2		;
	JR	CmpHex4		;

CmpHex2	SBS	EA,YZ		; @HL(lsb) < @WX(lsb), skip
	JR	CmpHex6		;

CmpHex4	POP	YZ		; skip return if @HL <= @WX
	POP	WX
	POP	HL
	POP	EA
	SRET

CmpHex6	REF	RRET_YZWXHLEA	; return if @HL > @WX


;***********************************************************
;	F: Compare 16-bit Hexadecimal Data
;	I: HL = 1st Data Start Pointer(msb)
;	   WX = 2nd Data Start Pointer(msb)
;	   YZ = Range Width(1B)
;	O: C = 1: @HL - Range <= @WX  < @HL + Range
;	     = 0: otherwise
;
CmpRange
	PUSH	EA
	PUSH	HL
	PUSH	WX
	PUSH	YZ

	LD	EA,@HL		; Load 1st data to HexBuf[]
	PUSH	EA		; & push to stack
	LD	HexBuf,EA	; (msb)
	REF	RINCS_2HL	; Couldn't skip normally
	LD	EA,@HL		;
	PUSH	EA		;
	RC