samcomm.src.bak

用SAM72N9写的电子秤文档

	RET			; exit

	BTST	HaveSample0	; Got 2 Samples?
	RET			;
	BTST	HaveSample1	;
	RET			;

	REF	RAverageSample	;
	
	BTST	EnCreeping
	JPS	MainCalculate22

	CALL	ChkZeroOne

	LD	HL,#PreviousCount	; compare with the previous count
	CALL	GetDif			; and check for creeping

	LD	EA,HexBuf+2		; store the difference for further
	LD	YZ,EA			; calculation

	LD	HL,#AverageCount	; HL = HexBuf = AverageCount
	LD	WX,#PreviousCount	; WX = DecBuf = PreviousCount
	REF	RCmpHex		; if @WX => @HL, skip
	JR	MainCalculate1
	LD	EA,#0FFh
	XOR	YZ,EA
	INCS	YZ
	NOP
MainCalculate1
	LD	EA,#CreepingDif4
	REF	RPutDec
	
	LD	HL,#HexBuf	; HL = HexBuf = weight change
	LD	WX,#DecBuf	; WX = DecBuf = Hold stable count
	REF	RCmpHex		; if @WX => @HL, skip
	JPS	MainCalculate22

;=====================================
; Check creep zero
MainCalculate20
	; HexBuf = ZeroCount - AverageCount
	LD	HL,#AverageCount
	LD	WX,#ZeroCount
	REF	RSubHex			; HexBuf = @WX - @HL

	BTST	C
	JR	MainCalculate20a
	JPS	MainCalculate20b	; if ZeroCount < Average Count, check no creep zero

MainCalculate20a
	LD	EA,#ZeroRtnUpBnd
	REF	RPutDec

	LD	HL,#DecBuf		; 
	LD	WX,#HexBuf		; HexBuf = ZeroCount - AverageCount
	REF	RCmpHex			; If @HL <= @WX, skip
	JPS	MainCalculate20b

	LD	EA,#ZeroRtnLowBnd
	REF	RPutDec

	LD	HL,#HexBuf		; HexBuf = ZeroCount - AverageCount
	LD	WX,#DecBuf		; 
	REF	RCmpHex			; If @HL <= @WX, skip
	JPS	MainCalculate20b

	BTST    CreepZero		; Check creep zero timer
	JPS     MainCalculate21
		
	RCF
	LD	EA,AverageCount+2	;
	LD	HL,#ZeroRtnUpBnd	;
	REF	RADC_EAHL		;
	LD	ZeroCount+2,EA		;
	LD	EA,AverageCount		;
	LD	HL,#0			;
	REF	RADC_EAHL		;
	LD	ZeroCount,EA		;

	REF	RSetBnd
	JPS	MainCalculate22
MainCalculate20b
	LD      A,#ZeroUpdate
	LD      Tag2sec,A	
	BITR    CreepZero	

;=====================================
; Check creeping exist
MainCalculate21
	BTST	TimrFinished		;
	JPS	MainCalculate26		; Creeping timer = 8s? 
	
	LD	HL,#0			; HL = MSB of different	
	LD	EA,#80h	
	RCF
	ADS	EA,YZ		
	JR	MainCalculate21a
	BTSF	ZeroOne
	JPS	MainCalculate22
	LD	HL,#0FFH
MainCalculate21a
	RCF				; ZeroCount = ZeroCount + diff
	LD	EA,ZeroCount+2		; lsb
	ADC	EA,YZ			;
	LD	ZeroCount+2,EA		;
	LD	EA,ZeroCount		; msb
	REF     RADC_EAHL		;
	LD	ZeroCount,EA		;
		
	RCF				; StartZero = StartZero + diff
	LD	EA,StartZero+2		; lsb
	ADC	EA,YZ			;
	LD	StartZero+2,EA		;
	LD	EA,StartZero		; msb
	REF     RADC_EAHL		;
	LD	StartZero,EA		;		

	REF	RSetBnd			; Set Zero Bound

MainCalculate22
	LD	A,#CreepTimer_RL4	; reset timer
	BTST	ZeroOne			;
	LD	A,#CreepTimer_RL6	;
	LD	CreepTimer,A		;
	BITR	TimrFinished		;

	LD      A,#ZeroUpdate		;
	LD      Tag2sec,A		;
	BITR    CreepZero		;
MainCalculate23	
	CALLS	Chk_4stepChange		;
	LD	HL,#PreviousCount	; AverageCount ---> PreviousCount
	REF	RGetAverageCnt

;------------------------------------------------------------------------
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 p