sam2t.src.bak

用SAM72N9写的电子秤文档

	REF	RSMB_Variable	; Select Variable

	LD	HL,#20H		; from 020h..0efh
RAMCL1	LD	A,#00h		; all fill 0
	LD	@HL,A		;
	INCS	HL		;
	LD	EA,#0efh	;
	REF	RCPSE_EAHL	;
	JR	RAMCL1		;
	RET
;-----------------------------------
ClearRAM1
	REF	RSMB_LCD 	; Select LCD Memory Bank1
	LD	HL,#0e0h	; from 1e0h .. 1f7h
RAMCL0	LD	A,#0h		; all fill 0
	LD	@HL,A		;
	INCS	HL		;
	LD	EA,#0f8h	;
	REF	RCPSE_EAHL	;
	JR	RAMCL0		;
	RET

;====== ARITHMETIC =================================================
;	F: 1 Nibble Multiplication
;	I: WX = Number 1 buf end pointer
;	   HL = Number 2 buf end pointer
;	   Y
;	   HexCalFlg = 1 : Use Hexadecimal calculation algorithm
;	               0 : Use Decimal calculation algorithm
;	O: @HL[] = @WX[] * Y
;	D: Y
;
Mul_1N	PUSH	EA
Mul_1N1	PUSH	HL
	PUSH	WX

	JPS	Mul_1N8

Mul_1N2	RCF
Mul_1N3	LD	A,@WX
	CALLS	AddA2HL
Mul_1N5	XCHD	A,@HL
	JR	Mul_1N6
	JR	Mul_1N7
Mul_1N6	DECS	X
	JR	Mul_1N3

Mul_1N7	POP	WX
	POP	HL
	JPS	Mul_1N1

Mul_1N8	DECS	Y
	JPS	Mul_1N2

Mul_1NE	REF	RRET_WXHLEA

;***********************************************************
;	F: 5-Digit Multiplication
;	I: YS_F_REG[] = Number 1
;	   YS_L_REG[] = Number 2
;	   HexCalFlg = 1 : Use Hexadecimal calculation algorithm
;	               0 : Use Decimal calculation algorithm
;	O: YS_R_REG[] = Multiple of Number 1 & 2
;	N: YS_R_REG[] = YS_F_REG[] * YS_L_REG[]
;	   No Overflow checking
;
Mul_YS	PUSH	EA
	PUSH	HL
	PUSH	WX
	PUSH	YZ

Mul_0	LD	HL,#YS_R_REG_4	;
Mul_1	LD	A,#0		; Clear all YS_R_REG
	XCHD	A,@HL		;
	JR	Mul_1		;

	LD	HL,#YS_L_REG_4	; 5 Digits multiple
Mul_2	LD	A,@HL		;
	REF	RCPSE_A0	;
	JR	Mul_4		;
Mul_3	DECS	L		;
	JR	Mul_2		;
Mul_E	REF	RRET_YZWXHLEA	;

Mul_4	LD	WX,#YS_F_REG_4	;
	LD	H,#((YS_R_REG_4 & 0F0h) / 16)
	LD	Y,A		;
	CALLS	Mul_1N		;
	LD	H,#((YS_L_REG_4 & 0F0h) / 16)
	JR	Mul_3		;

;***********************************************************
;	F: Multiplication 1byte x 4bit
;	I: EA = EA * Y
;	O: EA
;          C = 1: Overflow error
;	     = 0: Correct Result
;	N: Y <> 0
;
HexMul	PUSH	HL
	PUSH	YZ

	RCF
	LD	HL,#0
	DECS	Y
	JR	HexMul2
	JR	HexMul4

HexMul2	ADC	HL,EA
HexMul3	DECS	Y
	JR	HexMul2
HexMul4	LD	EA,HL

HexMulE	POP	YZ
	POP	HL
	RET

;***********************************************************
;	F: 5-Digit Addition
;	I: WL = Number 1 buf end pointer
;	   HL = Number 2 buf end pointer
;	   HexCalFlg = 1 : Use Hexadecimal calculation algorithm
;	               0 : Use Decimal calculation algorithm
;	O: HL = Result pointer
;
Add	PUSH	EA
	PUSH	HL

Add_1	RCF			; Clear carry flag
Add_2	LD	A,@WL		;
	CALLS	AddA2HL		;
Add_4	XCHD	A,@HL		; A <--> (HL),L <-- L - 1
	JR	Add_2		;

	REF	RRET_HLEA	;

;***********************************************************
;	F: Add digit array by 1 digit
;	I: HL = Array LSB pointer
;	   A = Digit to add
;	O: @HL
;	   EA, HL
;	D: HL, A
;
AddByLSB
	RCF			;
	JR	AddLSB2		;
AddLSB1	LD	A,#0		;
AddLSB2	CALLS	AddA2HL		;
	XCHD	A,@HL		;
	JR	AddLSB1		;
	RET

;***********************************************************
;	F: Double Array
;	I: HL = Array LSB pointer
;	O: @HL
;	   C = 1: Overflew
;	D: HL, A
;
Double_YS
	RCF			;
Dbl_YS1	LD	A,@HL		;
	CALLS	AddA2HL		;
	XCHD	A,@HL		;
	JR	Dbl_YS1		;
	RET

;***********************************************************
;	F: Add A and @HL with C
;	I: C, A, HL, HexCalFlg
;	O: A = Result
;	   C = overflow
;	N: HexCalFlg = 1, Hexadecimal addition
;	             = 0, Decimal addition
;
AddA2HL	BTST	HexCalFlg	;
	JR	AddA2HL_1	;
	ADC	A,@HL		; Hexadecimal addition
	RET
AddA2HL_1
	ADS	A,#6		; Decimal addition
	ADC	A,@HL		; If carry,skip next instruction
	ADS	A,#10		; This instruction have not skip function
	RET
;***********************************************************
;	F: 5-Digit Hexa-Decimal Division
;	I: YS_F_REG[] = Dividend
;	   YS_L_REG[] = Divisor
;	   HexCalFlg = 1 : Use Hexadecimal calculation algorithm
;	               0 : Use Decimal calculation algorithm
;	O: YS_F_REG[] = Quotient
;	   YS_R_REG[] = Remainder
;	N: YS_F_REG[] / YS_L_REG[] = YS_F_REG[]...YS_R_REG[]
;
Div_YS	PUSH	EA
	PUSH	HL
	PUSH	WX
	PUSH	YZ

	JPS	Div_8

Div_0	LD	HL,#YS_R_REG_4	;
Div_1	LD	A,#0		; Clear all YS_R_REG
	XCHD	A,@HL		;
	JR	Div_1		;
	LD	Z,#4		; 5 Digits division
Div_2	LD	HL,#YS_F_REG_4	; Shift YS_F_REG 1 digit right
	LD	A,#0		;
Div_3	XCHD	A,@HL		;
	JR	Div_3		; 0 --> (65),(65) --> (64),...,(61) --> (60)
				; (60) --> A
	LD	HL,#YS_R_REG_4	;
Div_4	XCHD	A,@HL		; A --> (85),(85) --> (84),...,(81) --> (80)
	JR	Div_4		; (80) --> A
Div_5	LD	WX,#YS_R_REG_4	;
	LD	HL,#YS_L_REG_4	;
	RCF			; Clear carry
Div_6	LD	A,@WL		; YS_R_REG <-- YS_R_REG - YS_L_REG
	BTST	HexCalFlg	;
	JR	Div_61		;
	SBC	A,@HL		;
	JR	Div_62		;

Div_61	SBC	A,@HL		;
	ADS	A,#0AH		; Decimal adjustment

Div_62	XCH	A,@WL		;
	DECS	L		;
	JR	Div_6		;
	BTST	C		; Check borrow
	JPS	Div_7		; Borrow is not generated
	LD	WX,#YS_L_REG_4	; Borrow is generated by subtraction
	LD	HL,#YS_R_REG_4	; YS_R_REG <-- YS_R_REG + YS_L_REG
	CALLS	Add		;
Div_64	DECS	Z		;
	JPS	Div_2		; Next digit selection
	LD	HL,#YS_F_REG	;

	REF	RRET_YZWXHLEA

Div_7	LD	HL,#YS_F_REG_4	;
	INCS	@HL		; Increment quotient by 1
	NOP			;
	JPS	Div_5		; and subtract until a borrow is generated

Div_8	LD	HL,#YS_L_REG_4	;
	LD	A,#0		;
Div_9	OR	A,@HL		;
	DECS	L		;
	JR	Div_9		;

	REF	RCPSE_A0	;
	JPS	Div_0		;

Div_ERR	REF	RRET_YZWXHLEA	; DIVIDE BY ZERO

;***********************************************************
;	F: Decimal Round off
;	I: YS_L_REG[] = Divisor
;	   YS_R_REG[] = Remainder
;	   HexCalFlg = 1 : Use Hexadecimal calculation algorithm
;	               0 : Use Decimal calculation algorithm
;	O: YS_F_REG[] = Quotient
;
Round_YS
	PUSH	EA
	PUSH	HL
	PUSH	WX

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

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

	LD	Y,#10		;
	LD	WX,#YS_R_REG_4	; YS_R_REG[] = YS_R_REG[] * 10
	LD	HL,#DecBuf4	;
	CALLS	Mul_1N		;
	LD	WX,#DecBuf4	; Copy DecBuf[] to YS_R_REG[]
	LD	HL,#YS_R_REG_4	;
	REF	RCpyBuf		;

	LD	WX,#YS_L_REG_0	; Compare YS_L_REG[] & YS_R_REG[]
	LD	HL,#YS_R_REG_0	;
	CALL	CmpDig		; skip return if YS_L_REG[] < YS_R_REG[]
	JR	Rnd_E		; Not Round

	LD	A,#1		; Round up YS_F_REG[] by 1
	LD	HL,#YS_F_REG_4	;
	CALLS	AddByLSB	;

Rnd_E	REF	RRET_WXHLEA	;
	RET

;***********************************************************
;	F: Convert 4-digit array to 16-bit word
;	I: WX = Source (End buf pointer)
;	   HL = Destination (lsb 8-bit pointer)
;	O: HL = Result
;	D: EA, HL, WX
;
Ary2Wrd	PUSH	YZ
	LD	Y,#1		;
Ay2Wd1	LD	A,@WX		;
	DECS	X		; (Shouldn't skip)
	XCHI	A,@HL		;
	LD	A,@WX		;
	DECS	X		; (Shouldn't skip)
	XCHD	A,@HL		;
	REF	RDECS_HL	;
	REF	RDECS_HL	;
	NOP			;
	DECS	Y		;
	JR	Ay2Wd1		;
	POP	YZ
	RET


;====== SLEEP TIME SETTING ROUTINE ==================================

;***********************************************************
;	F: EnIdle....  - if Sleep mode is not enabled, enable it
;	   RstIdle.... - reset sleep timer whatever it have enabled or not
;	D: EA
;
RL_BLT					; Battery low
RL_ZRT					; zero reading
RL_OWT	LD	EA,#Idle1minL_RL	; overweight
	LD	SleepTimL,EA		; load low byte
	LD	SleepTimLRL,EA	
	JR	RL_COMM1
RL_CRT					; normal 
RL_UWT					; under weight
	BTST	PowerOffTim		; check sleep time 
	LD	EA,#Idle3minL_RL	; load low byte
	LD	EA,#Idle10minL_RL	
	LD	SleepTimL,EA
	LD	SleepTimLRL,EA
	
	BTST	PowerOffTim
RL_COMM1
	LD	A,#IdleminH_RL		; load high nibble
	LD	A,#Idle10minH_RL
RL_COMM	
	LD	SleepTimH,A
	LD	SleepTimHRL,A
	RET

;***********************************************************
;	F: Set Zero reading sleep timer count down timer mode
;	I: LDigit1xxx, LDigitx1xx, LDigitxx1x, LDigitxxx1
;	   SDigitx_8
;	D: EA, HL, WX
;
SetSleepTimer
	BTSF	IdleBatLowNow	; if Battery low now, exit
	RET			;
SetST1
	LD	HL,#LDigit1xxx+1; Chk display value is zero or not
SetST2	DECS	L		;
	LD	EA,#LDsp_0	;
	CPSE	EA,@HL		; Digit = 0?
	JPS	SetST4		;
SetST3	REF	RDECS_HL	;
	NOP			;
	CPSE	L,#0dh		; Check large digit except decimal
	JR	SetST2		;

	LD	A,SDigitx_8	;
	CPSE	A,#SDsp_Nul	;
	JR	SetST5		;

	BTSF	Icon_One	; Check for 10kg pace
	JR	SetST5		;
	
	BITS	ZeroRdNow	; Zero reading
	BITR	CnstRdNow	;
	JR	SetST6		;

SetST4	LD	EA,#LDspNul	;
	CPSE	EA,@HL		; Digit = Null?
	JR	SetST5		;
	JPS	SetST3		;

SetST5	BITR	ZeroRdNow	;
	BITS	CnstRdNow	;

SetST6	
	BTST	ChgeSlpTmrNow	; if now have 4 steps changed, skip
	RET			;
	BITR	ChgeSlpTmrNow

	BTSF	OvrWtNow	; if now not overweight, skip
	JR	RstIdleOWT	;
	BTSF	UdrWtNow	; if now not underweight, skip
	JR	RstIdleUWT	;
	BTSF	CnstRdNow	; if now not constant reading, skip
	JPS	RstIdleCRT	;
	BTSF	ZeroRdNow	; if now not zero reading, skip
	JPS	RstIdleZRT	;
	RET

RstIdleOWT
	BTST	IdleOvrWtNow	;
SetIdleOWT
	CALLS	RL_OWT		;
	JPS	Rst_IO		;

RstIdleUWT
	BTST	IdleUdrWtNow	;
SetIdleUWT
	CALLS	RL_UWT		;
	JR	Rst_IU		;

RstIdleCRT
	BTST	IdleCnstRdNow	;
SetIdleCRT
	CALLS	RL_CRT		;
	JR	Rst_IC		;

RstIdleZRT
	BTST	IdleZeroRdNow	;
SetIdleZRT
	CALLS	RL_ZRT		;
	JR	Rst_IZ		;

Rst_IC	LD	A,#0001b	; set IdleCnstRdNow
Rst_IO	LD	A,#0010b	; set IdleOvrWtNow
Rst_IU	LD	A,#0100b	; set IdleUdrWtNow
Rst_IZ	LD	A,#1000b	; set IdleZeroRdNow
	LD	OperFlg9,A	;
	RET

SetST_RL
	LD	EA,SleepTimLRL	;	
	LD	SleepTimL,EA	;
	LD	A,SleepTimHRL	;	
	LD	SleepTimH,A	;
	BITR	SleepNow	;
	RET

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