samcomm.src.bak

用SAM72N9写的电子秤文档

;***********************************************************
ChkHoldState
	BTST	HoldEn		; Check is Hold enable
	RET			;

	LD	HL,#HoldChkCount	; restore previous interal count
	CALL	ChkHoldStable		;
	
	BTSF	HoldRd		; Check is the reading is not Hold
	JPS	ChkHoldState_Ret

	BTST	HoldStableChk	; Check time interval reach
	RET			;

	BITR	HoldStableChk
	LD	A,#HoldChkTime	; Reset timer
	LD	HoldTimer,A	;

	LD	A,OperFlg8	; Check OperFlg8 to determinate is it sitable for hold
	AND	A,#1110b	;
	REF	RCPSE_A0	;
	JPS	ChkHoldState_Ex	;

	BTSF	HoldRd		; Check is the reading is not Hold
	JPS	ChkHoldState_Ret

	BTSF	HoldRdChange	; Check is there any reading change
	JR	ChkHoldState_Ret

	BTSF	HoldNotAllow	;
	JR	ChkHoldState_Ret;

	CALL	KeyTone		; Beep !!!
	BITS	HoldRd		; --
	LD	A,#HoldTimConst	; Reset Hold timer
	LD	HoldTimer,A	;
	JR	ChkHoldState_Ret
ChkHoldState_Ex
	BITS	HoldNotAllow	;
ChkHoldState_Ret
	BITR	HoldRdChange	;
	RET

;====== CALCULATION ================================================

;***********************************************************
;	F: Check weight taring function
;	I: WeightTareNow = 1: Weight Tare
;	O: WeightTareNow, ZeroOffset, ZeroCount, NewWeightCnt, NewWeightBCD
;	   CnstRdNow, ZeroRdNow
;	N: if OvrWtNow set, exit
;	   if OvrAbMaxNow set, exit
;	   if UdrWtNow set, No tare, reset zero position
;
ChkWeightTare
	BTST	WeightTareNow	;
	RET			;
	
	REF	RSMB_MemMapIO	;
ChkWeightTare1
; REMARK IT BY HUANG
	BTSF	ONZERO_PIN

	JR	ChkWeightTare2
	REF	RSMB_Variable   ;
	RET
	
ChkWeightTare2
	REF	RSMB_Variable   ;

	BITR	WeightTareNow	;

	BTSF	HoldEn		; if hold enable, no function
	RET			;

	BTSF	OvrWtNow	; If over weight now, exit
	RET			;
	BTSF	OvrAbMaxNow	; If over absolute max count, exit
	RET			;
	BTSF	OvrHiVoltNow	; If over Hi-Volt Boundary, exit
	RET			;
	BTSF	BlwLoVoltNow	; If below Lo-Volt Boundary, exit
	RET			;
	BTSF	HoldRd		; If Hold enable now, exit
	RET			;

WeightTare
	CALLS	SetIdleZRT	; Set zero-reading sleep time
	BTST	UdrWtNow	;
	JR	WeightTare1	;
	CALLS	UdrWgtProc2	; If under weight now, reset zero position
	BITR	OvrWtNow	; Clear OvrWtNow
	RET			;
WeightTare1
	BTSF	CalibrateOn	; In Calibration mode, no totaling function
	JPS	WeightTare10
	BTST	TotalFlag
	JPS	WeightTare10			
	BTST	TareNow
	JPS	WeightTare9
;-----------------------------------------
; Totalling occur	
	LD	EA,StartZero+2	;  StartZero ---> ZeroCount
	LD	ZeroCount+2,EA
	LD	EA,StartZero
	LD	ZeroCount,EA
	
	BITR	TareNow
	BITR	Icon_Tare
	JR	WeightTareE
WeightTare9
	BITS	TareNow
	BITS	Icon_Tare
WeightTare10	
	CALL	Dly60			; DELAY 600ms	
;-------------------------------------------
; Tare occur (default)
	REF	RAverageSample
	LD	HL,#ZeroCount
	REF	RGetAverageCnt

WeightTareE
	REF	RSetBnd		;	
	REF	RCalWeightCnt	;

	CALLS	InitWeightBCD	;
	BITR	UdrWtNow	; Clear UdrWtNow
	RET

;***********************************************************
;	F: Underweight Procedures
;	I: UdrWtNow, AverageCount, NewWeightCnt
;	O: ZeroOffset, ZeroCount
;	   IdleUdrWtNow = 1: currently is underweight
;	                = 0: currently is not underweight
;	D: EA, HL, WX, YZ
;
UnderweightProc
	BITR	OvrWtNow	; Clear OvrWtNow

	CALL	DspUnderWeight	;

	BTST	AutoZeroNow	; 1 = Reset Zero now
	RET
UdrWgtProc2
	CALLS	Dly20			; DELAY 400ms
	CALLS	Dly20
	REF	RAverageSample		;	

	BTST	TotalFlag
	JPS	UdrWgtProc4	
	
	BTSF	TareNow
	JR	UdrWgtProc3

	LD	HL,#StartZero	; Reset Zero Reading
	REF	RGetAverageCnt

	JPS	UdrWgtProc4
UdrWgtProc3	
	BITR	TareNow
	BITR	Icon_Tare
	
	LD	EA,StartZero	; Reset Zero Reading
	LD	ZeroCount,EA	; MSB
	LD	EA,StartZero+2
	LD	ZeroCount+2,EA	; LSB
	JR	UdrWgtProc7	
UdrWgtProc4
	LD	HL,#ZeroCount
	REF	RGetAverageCnt
UdrWgtProc7	
	REF	RCalWeightCnt	; get NewWeightCnt
	REF	RSetBnd		;
	CALLS	InitWeightBCD	;
	RET

;***********************************************************
;	F: Overloading Procedure
;	I: IdleOvrWtNow
;	D: EA
;
OverloadingProc
	BITR	UdrWtNow	; Clear UdrWtNow

	BITR	HoldRd		; if loading occur,disable hold reading
	BITR	HoldStableChk	;
	BITS	HoldNotAllow	; 
	LD	A,#HoldChkTime	; Reset timer
	LD	HoldTimer,A	;

	CALL	DspOverloaded	;
	RET

;***********************************************************
;	F: Check if now underweight
;	I: AverageCount, ZeroBound
;	O: Skip return if underweight(ZeroBound >  AverageCount)
;	   return if not underweight or OvrAbMaxNow set
;	D: HL, WX
;
ChkUnderweight
	BTSF	OvrAbMaxNow	;
	RET

ChkUnderweight1
	LD	HL,#ZeroBound	;
	LD	WX,#AverageCount;
	REF	RCmpHex		; If @HL <= @WX, skip
	SRET			;
	RET			;

;***********************************************************
;	F: Check if now overloading
;	I: NewWeightCnt, MaxBound
;	O: Skip return if overloading(MaxBound <  NewWeightCnt + ZeroOffset) or OvrAbMaxNow set
;	   return if Not overloading(MaxBound >= NewWeightCnt + ZeroOffset)
;	D: HexBuf[], EA, HL, WX
;
ChkOverloading
	BTSF	OvrAbMaxNow	;
	SRET			;
	BTSF	CntDspNow	;
	RET

	LD	HL,#StartZero	;
	LD	WX,#AverageCount;
	REF	RCmpHex		; if @HL <= @WX, skip
	RET			;

	; HexBuf = AverageCount - StartZero
	LD	HL,#StartZero
	LD	WX,#AverageCount
	REF	RSubHex			; HexBuf = @WX - @HL

	LD	HL,#HexBuf	; HexBuf = AverageCount - StartZero
	LD	WX,#MaxBound	;
	REF	RCmpHex		; If @HL <= @WX, skip
	SRET			;
	RET			;

;***********************************************************
;	F: To Round NewWeightCnt correct to step count width for kg/ml mode
;	I: NewWeightCnt
;	O: NewWeightCnt
;
Rnd2Step_kgml
	LD	WX,#YS_F_REG_4	;
	REF	RCurStep2Ary	;
	REF	RDiv_10_FReg	;
	REF	RCpy_F2LReg	;

	LD	HL,#NewWeightCnt+2
	LD	WX,#YS_F_REG_4	; Copy NewWeightCnt to YS_F_REG[]
	REF	RWrd2Ary	;
	REF	RDiv_YS		;
	REF	RRound_YS	; Round to nearest step in kg/ml
	LD	WX,#YS_F_REG_4	; Copy YS_F_REG[] to DecBuf[]
	LD	HL,#DecBuf4	; for backup
	REF	RCpyBuf		;

	REF	RActCurStp2Ary	;
	REF	RCpy_F2LReg	;
	LD	WX,#DecBuf4	; Copy DecBuf[] to YS_F_REG[]
	LD	HL,#YS_F_REG_4	; for restore
	REF	RCpyBuf		;
	CALLS	Mul_YS		;

	LD	WX,#YS_R_REG_4	; Copy YS_R_REG[] to NewWeightCnt
	LD	HL,#NewWeightCnt+2
	CALLS	Ary2Wrd		;
	RET

;***********************************************************
;	F: To Round NewWeightCnt correct to step count width for fl.oz mode
;	I: NewWeightCnt
;	O: NewWeightCnt
;
Rnd2Step_floz
	REF	RNWCnt2FReg	;
	REF	RMul_10_FReg	;
	CALLS	Cal_oz_Part	; oz = remainder / ozRatio
	REF	RCpy_R2FReg	; get remainder
	JR	Rnd2Stpoz1	;

;***********************************************************
;	F: To Round NewWeightCnt correct to step count width for oz/lb mode
;	I: NewWeightCnt
;	O: NewWeightCnt
;
Rnd2Step_lb
	CALL	lbRatio2LReg	;
	REF	RNWCnt2FReg	;
	REF	RDiv_YS		; LB = NewWeightCnt / lbRatio
	REF	RCpy_R2FReg	; get remainder
	REF	RMul_10_FReg	;
	CALLS	Cal_oz_Part	; oz = remainder / ozRatio
	REF	RCpy_R2FReg	; get remainder
Rnd2Stpoz1
	LD	WX,#YS_L_REG_4	;
	REF	RCurStep2Ary	; 1/8oz step
	REF	RDiv_YS		;
	LD	A,YS_F_REG_4	;
	REF	RRound_YS	;
	LD	HL,#YS_F_REG_4	;
	CPSE	A,@HL		; if no round, skip
	JR	Rnd2Stpoz2	;
	RET

Rnd2Stpoz2
	REF	RActCurStp2Ary	;

	LD	HL,#YS_F_REG_4	;
	REF	RDouble_YS	;
	LD	HL,#YS_F_REG_4	; YS_L_REG[] = YS_L_REG * 4
	REF	RDouble_YS	;
	REF	RDiv_10_FReg	;

;	LD	A,FactoryMode	;
;	CPSE	A,#5		; if mode 6 - lb mode, RDiv_10_FReg once more
;	JR	Rnd2Stpoz3	;
;	JR      Rnd2Stpoz5
	;BTSF	UnitMode	;
	;REF	RDiv_10_FReg	;
;Rnd2Stpoz3
;        DECS    A
;        JR      Rnd2Stpoz8
;Rnd2Stpoz5	
;	BTSF	UnitMode	;
;	REF	RDiv_10_FReg	;        
Rnd2Stpoz8
	REF	RRound_YS	;
	LD	WX,#YS_F_REG_4	; Convert YS_L_REG[] to HexBuf[]
	LD	HL,#HexBuf+2	;
	CALLS	Ary2Wrd		;

	RCF			;
	LD	EA,HexBuf+2	; NewWeightCnt = NewWeightCnt + HexBuf
	REF	RLD_HLEA	;
	LD	EA,NewWeightCnt+2
	REF	RADC_EAHL	; Substract LSB
	LD	NewWeightCnt+2,EA;
	LD	EA,HexBuf	;
	REF	RLD_HLEA	;
	LD	EA,NewWeightCnt	;
	REF	RADC_EAHL	; Substract MSB
	LD	NewWeightCnt,EA	;
	RET

;***********************************************************
;	F: Part routine to calculate oz
;	I: YS_F_REG[], ozRatio
;	O: YS_F_REG[] = oz
;	   YS_R_REG[] = Remainder
;	D: A
;
Cal_oz_Part
	CALL	ozRatio2LReg	;
	REF	RDiv_YS		;
	RET

;***********************************************************
;	F: Calculate kg
;	I: NewWeightCnt[] - Relative count of weight
;	   gRatio - Count per 1g
;	O: NewWeightBCD[]
;	N: kg/ml dsp = NewWeightCnt/(CurStep/10)*StepVal
;	D: EA, HL, WX, YZ
;
CalculateML
CalculateKG	
	CALLS	Rnd2Step_kgml
	CALLS	CalStepVal	;
	PUSH	EA		;

	REF	RActCurStp2Ary	;
	REF	RCpy_F2LReg	;
	REF	RNWCnt2FReg	;
	REF	RDiv_YS		;

	POP	EA		;

	CALL	Mul_EA_FReg	; YS_F_REG = YS_F_REG * step value
	REF	RHxFReg2Dec	;
	LD	HL,#NewWeightBCD4
	LD	WX,#DecBuf4	; Copy DecBuf[] to NewWeightBCD[]
	REF	RCpyBuf		;
	RET

;***********************************************************
;	F: Calculate solid oz/lb
;	I: NewWeightCnt
;	O: NewWeightBCD[]
;	D: EA, HL, WX, YZ
;
CalculateLB
	CALLS	Rnd2Step_lb	;
	CALLS	CalStepVal	;
	PUSH	EA		;

	CALL	lbRatio2LReg	;
	REF	RNWCnt2FReg	;
	REF	RDiv_YS		; LB = NewWeightCnt / lbRatio

	REF	RHxFReg2Dec	;
	
	LD	A,FactoryMode	;
	DECS    A               ; if mode = 1, fill first one display location only
	JR      CalculateLB1
	LD	A,DecBuf4	;
	LD	NewWeightBCD0,A	;
	JR      CalculateLB2
CalculateLB1	
	LD	A,DecBuf4	;
	LD	NewWeightBCD1,A	;
	LD	A,DecBuf3	;
	LD	NewWeightBCD0,A	;
;-----
CalculateLB2
	REF	RCpy_R2FReg	; get remainder
	REF	RMul_10_FReg	;

	CALLS	Cal_oz_Part	; return YS_F_REG[] ... YS_R_REG[]

	REF	RHxFReg2Dec	;
	
	LD	A,FactoryMode	;
	DECS    A               ; if mode = 1, fill next two display location only
	JR      CalculateLB5
	LD	A,DecBuf3	;
	LD	NewWeightBCD1,A	;
	LD	A,DecBuf4	;
	LD	NewWeightBCD2,A	;
	JR      CalculateLB6
CalculateLB5		
	LD	A,DecBuf4	;
	LD	NewWeightBCD3,A	;
	LD	A,DecBuf3	;
	LD	NewWeightBCD2,A	;
;-----
CalculateLB6
	REF	RCpy_R2FReg	; get remainder

	LD	WX,#YS_L_REG_4	;
	REF	RCurStep2Ary	;
	REF	RDiv_YS		;
	POP	EA		; get step value
	CALL	Mul_EA_FReg	;

        LD	A,FactoryMode	;
	DECS    A               ; if mode = 1, fill last one display location only
	JR      CalculateLB60
	REF	RHxFReg2Dec	; Hex --> Dec
	LD	A,DecBuf4	;
	
	LD	NewWeightBCD3,A	;
	JR      CalculateLB70
CalculateLB60	
	LD	A,YS_F_REG_4	;
	LD	NewWeightBCD4,A	;
CalculateLB70	
	RET
;***********************************************************
;	F: Calculate Fuild oz
;	I: NewWeightCnt
;	O: NewWeightBCD[]
;	D: EA, HL, WX, YZ
;
CalculateFLOZ
	LD	A,FactoryMode
	DECS    A               ; if mode = 1, use CalculateLB
	JR	CalculateFLOZ_1
	JPS	CalculateLB
CalculateFLOZ_1
	CALLS	Rnd2Step_floz	;
	CALLS	CalStepVal	;
	PUSH	EA		;

	CALL	ozRatio2LReg	;
	LD	WX,#YS_L_REG_4	;
	LD	HL,#YS_F_REG_4	;
	REF	RCpyBuf		; Copy YS_L_REG[] to YS_F_REG[]
	REF	RDiv_10_FReg	;
	REF	RCpy_F2LReg	;

	REF	RNWCnt2FReg	;
	REF	RDiv_YS		;
	REF	RHxFReg2Dec	;
	LD	WX,#DecBuf4	;
	LD	HL,#NewWeightBCD3
	CALL	CpyBuf2		;
;------
	REF	RCpy_R2FReg	; get remainder
	REF	RMul_10_FReg	;
	LD	WX,#YS_L_REG_4	;
	REF	RCurStep2Ary	;
	REF	RDiv_YS		;
	POP	EA		; get step value
	CALL	Mul_EA_FReg	;

	LD	A,YS_F_REG_4	;
	LD	NewWeightBCD4,A	;
	RET

;***********************************************************
;	F: Check 4 dsp Step change
;	I: AverageCount, NewWeightCnt, ZeroCount
;	O: Chge4stepNow = 0: within 4 dsp step range
;	                = 1: beyond 4 dsp step count
;
Chk_4stepChange
	LD	HL,#PreviousCount	; compare with previous count
	CALL	GetDif			; and check 4 step change

	REF	RActCurStp2Ary	;
	LD	HL,#YS_F_REG_4	;
	REF	RDouble_YS	;
	LD	HL,#YS_F_REG_4	;
	REF	RDouble_YS	;
	LD	WX,#YS_F_REG_4	;
	LD	HL,#DecBuf+2	; DecBuf = Step Count * 4
	CALLS	Ary2Wrd		;

	LD	HL,#HexBuf	; HL = HexBuf = weight change
	LD	WX,#DecBuf	; WX = DecBuf = 4 step count
	REF	RCmpHex		; if @WX => @HL, skip
	JR	GoSetSlpTmr	;
	RET			;
GoSetSlpTmr
	BITS	Chge4stepNow	;
	BITR	IdleCnstRdNow	;
	BITR	IdleZeroRdNow	;

	BITR	ChgeSlpTmrNow
	LD	A,#ChgeSlpTmrDly	; Reset set sleep timer delay
	LD	Chge4stepTimer,A
	RET

;***********************************************************
;	F: Main Calculation Routine
;	I: SampleCount0, SampleCount1, HaveData, UnitMode
;	O: NewWeightBCD
;	   LDigitxxx1, LDigitxx1x, LDigitx1xx, LDigit1xxx
;	D: EA, HL, WX, YZ
;
MainCalculate
	BTSF	IdleBatLowNow	; if battery low now,