;************************************************************************
;
;	Down Load process part
;
POD	.EQU	1
TEST	.EQU	1	
;
;*************************************************************************
;
;
Flash_Main:
;-------------------------------------------------------------------------
;	ransfer down load program to RAM area 
;-------------------------------------------------------------------------
Transfer1:
   mov.w   #(RAM_INIT & 0ffffh),a0   	; Transfer source address (Low)
   mov.b   #(RAM_INIT >> 16),r1h     	; Transfer source address (high)
   mov.w   #RAM_PG_TOP,a1             	; Transfer destination address
   mov.w   #(F_PROG_END - RAM_INIT+20)/2,r3 ; Transfer number
   smovf.w                		; String move
   LDC		#4500H,ISP		; 
   JMP	    RAM_PG_TOP			; after receiving execute(1), 
				     	; it elase user area
;-------------------------------------------------------------------------
;	executive part on RAM 
;-------------------------------------------------------------------------
					;Receive the BIN data of the 1st time,
Flash_Main2:				;and execute RAM program.
	JMP	(RAM_INIT_D-RAM_INIT+RAM_PG_TOP)

;-------------------------------------------------------------------------
;	The clearance of the flash area
;-------------------------------------------------------------------------
RAM_INIT:
;-------------------------------------------------------------------------****
;	A setup of wait for writing to the flash memory 
;-------------------------------------------------------------------------****
;	When you change main clock,you must set up movement frequency and
;	wait to write to flash memory.
;	inside wait			Less than 12.5MHz
;	inside weight is not in		Less than 6.25MHz
;
;	(attention)
;	you must take the same change in 152th line on this file.
;
;-------------------------------------------------------------------------****
	BSET	0,0AH					;protection register
	MOV.B	#01000000B,CM1				;1/2 cycle
;	MOV.B	#00000000B,CM1				;1 cycle
	BCLR	6,CM0
	BCLR	0,0AH					;protection register	
	BSET	1,0aH					;protection register		
;	BSET	7,PM1					;1WAITE	
	BCLR	7,PM1					;0WAITE	
	BCLR	1,0AH					;protection register
;-------------------------------------------------------------------------****
.IF POD==1
INIT_LOOP:				;
	BTST	FER0,FER
	JNC	INIT_LOOP	
.ENDIF
	BCLR	1,FER		
	BSET	1,FER	
	MOV.W	#0CH,A1		;counter
INIT_LOOP_2:			;clear from C0000H to E0000H
	MOV.W	#20H,R0
	;MOV.W	#0CH,A1	
	MOV.W	#0FFFEH,A0	
	STE.W	R0,[A1A0]
	MOV.W	#0D0H,R0
	;MOV.W	#0CH,A1	
	MOV.W	#0FFFEH,A0	
	STE.W	R0,[A1A0]
.IF POD==1
INIT_LOOP_3:
	BTST	FER0,FER
	JNC	INIT_LOOP_3
.ENDIF
	ADD.W	#1H,A1
	CMP.W	#0FH,A1
	JNZ	INIT_LOOP_2
.IF POD==1
INIT_LOOP_5:
	BTST	FER0,FER
	JNC	INIT_LOOP_5
.ENDIF
	MOV.W	#20H,R0
	MOV.W	#0FH,A1	
	MOV.W	#07FFEH,A0	;
	STE.W	R0,[A1A0]
	MOV.W	#0D0H,R0
	MOV.W	#0FH,A1	
	MOV.W	#07FFEH,A0	;
	STE.W	R0,[A1A0]
.IF POD==1
INIT_LOOP_6:
	BTST	FER0,FER
	JNC	INIT_LOOP_6
.ENDIF
	MOV.W	#20H,R0
	MOV.W	#0FH,A1	
	MOV.W	#09FFEH,A0	;
	STE.W	R0,[A1A0]
	MOV.W	#0D0H,R0
	MOV.W	#0FH,A1	
	MOV.W	#09FFEH,A0	;
	STE.W	R0,[A1A0]
.IF POD==1
INIT_LOOP_7:
	BTST	FER0,FER
	JNC	INIT_LOOP_7
.ENDIF
	MOV.W	#20H,R0
	MOV.W	#0FH,A1	
	MOV.W	#0BFFEH,A0	;
	STE.W	R0,[A1A0]
	MOV.W	#0D0H,R0
	MOV.W	#0FH,A1	
	MOV.W	#0BFFEH,A0	;
	STE.W	R0,[A1A0]
.IF POD==1
INIT_LOOP_8:
	BTST	FER0,FER
	JNC	INIT_LOOP_8
.ENDIF
	MOV.W	#0FFH,R0
	MOV.W	#0FH,A1		
	MOV.W	#0FFFEH,A0	
	STE.W	R0,[A1A0]	
.IF POD==1
INIT_LOOP_10:
	BTST	FER0,FER
	JNC	INIT_LOOP_10
.ENDIF	
	BSET	0,0AH		;protection register
	MOV.B	#00000000B,CM1	;1/2 cycle
	BCLR	0,0AH	
	BSET	1,0AH
	BCLR	7,PM1
	BCLR	1,0AH		;protection register	
	JMP.A	L_DWNH_JMP_RETURN
.IF POD==1
FLA_COM:	
	BTST	FER0,FER
	JNC	FLA_COM
.ENDIF
	STE.W	R0,[A1A0]
	RTS	
;------------------------------------------------------------------------
;	A setup of interrupt vector table such as UART
;------------------------------------------------------------------------
RAM_INIT_D:
;-------------------------------------------------------------------------****
;	A setup of wait for wrintg to the flash memory writing
;-------------------------------------------------------------------------****
;	When you change main clock,you must set up movement frequency and
;	wait to write to flash memory.
;	inside wait			Less than 12.5MHz
;	inside weight is not in		Less than 6.25MHz
;-------------------------------------------------------------------------****
	BSET	0,0AH					;protection register
	MOV.B	#01000000B,CM1				;1/2 cycle
;	MOV.B	#00000000B,CM1				;1 cycle
	BCLR	6,CM0
	BCLR	0,0AH	

	BSET	1,0AH
;	MOV.B	#10001000B,PM1				;1 wait
	MOV.B	#00001000B,PM1				;no wait
	BCLR	1,0AH					;protection register
;-------------------------------------------------------------------------****
	MOV.W	#0,F_REQ				;request initialization
	MOV.W	#(F_SEND-RAM_INIT+RAM_PG_TOP),A0	;transmission
	MOV.W	A0,F_INTB+19*4				;UART0 interrupt vector M,L
	MOV.W	#00H,F_INTB+19*4+2			;UART0 interrupt vector H
;
	MOV.W	#(F_RECIEVE-RAM_INIT+RAM_PG_TOP),A0	; receiving 
	MOV.W	A0,F_INTB+20*4				;UART0 interrupt vector M,L
	MOV.W	#00H,F_INTB+20*4+2			;UART0 interrupt vector H
	MOV.B	#00000101B,U1MR				; when receiving datas ,set stop_bit 1
;
.IF POD == 0
	MOV.B	#10000100B,TA0MR
	MOV.W	#3125,TA0
	BSET	TA0S
.ENDIF	
	LDINTB	#F_INTB					;04000H
	
	MOV.W	#0,W_BUFF_NUM		;initialization writing buffer number 
	MOV.W	W_BUFF_NUM,FF_BUFF_NUM
	JSR	F_FILL_BUFF_FF		;fill the buffer with data 0FFH
	
	MOV.W	bdwnh_adr,BORDER_AD_ML		;for compairing 
	MOV.W	bdwnh_adr+2,BORDER_AD_H		;for compairing

;------------------------------------------------------------------------
;	initialization variable
;------------------------------------------------------------------------
	MOV.W	#0,R_BUFF_NUM		;buffer number for reading
	MOV.W	#0,W_BUFF_NUM		;buffer number for writing
	MOV.W	#0,WRITE_POINT		;reset command pointer
	MOV.W	#0,READ_POINT		;
	MOV.W	#0,COM_COUNT		; command counter
	MOV.B	#0,data_count
	MOV.B	#0,data_w_point
	MOV.B	#0,data_r_point
;
	SUB.W		#1,bdwnh_adr		;address compensation	
	SBB.W		#0,bdwnh_adr+2		;
	ADD.W		#1,wdwnh_len		;length compensation
;

;-------	RAM_MAIN	----------------
;
RAM_MAIN:
	
COMMAND_CHACK_ROUTIN:	
.IF	POD==1				;
	BTST	FER0,FER		;the condition of flash memory =BUSY?
	JNC	RECIVE_CH		;YES-> check receiving
.ELSE
	BTST	IR_TA0IC		;for Pod testing
	JNC	RECIVE_CH		;
	BCLR	IR_TA0IC		;
.ENDIF	
	MOV.W	F_REQ,R0		;no flow control？
	BTST	F_ESC_NOR,R0		;
	JC	NOT_X_CONT_2		;YES->process in the cace without flow control
	MOV.W	COM_COUNT,R0		;command counter = 0 ?
	CMP.W	#0,R0			;don't execute
	JZ	RECIVE_CH		;	
	JNC	RECIVE_CH		;less than 0?

	MOV.W	READ_POINT,A0		;reading the pointer for reading the buffer of storage command.
	MOV.W	COMMAND_BUFF[A0],R0	;

	CMP.W	#R_ALAY_RQ,R0		; Is command read alay ？
	JZ	CH_READ_ALEY_CALL	;YES->to the execute read alay routin 
	CMP.W	#PAGE_RQ,R0		; Is command は page program？
	JZ	CH_PAGE_CALL		;YES->to the execute  page program routin 

	JMP	RECIVE_CH		;if there is no command,check the receiving data.	
CH_READ_ALEY_CALL:
	MOV.W	READ_POINT,A0		;
	MOV.W	AD_ML_BUFF[A0],READ_ALAY_AD_ML
	MOV.W	AD_H_BUFF[A0],READ_ALAY_AD_H
	JSR	CH_READ_ALEY		;
	JMP	C_C_R_END
CH_PAGE_CALL:
	MOV.W	READ_POINT,A0			;
	MOV.W	AD_ML_BUFF[A0],PAGE_ADR_ML	;
	MOV.W	AD_H_BUFF[A0],PAGE_ADR_H	;
	MOV.W	COM_NUM_BUFF[A0],R_BUFF_NUM	;
	JSR	CH_PAGE	
	JMP	C_C_R_END
C_C_R_END:
	ADD.W	#2,READ_POINT
	CMP.W	#WRITE_MAX,READ_POINT			;
	JNZ	RESET_READ_P			;
	MOV.W	#0,READ_POINT			
RESET_READ_P:
	JMP	RECIVE_CH		;if there is no command,check the receiving data.
;
;-------------------------------------------------------------------------
;		 judegement receiving 
;-------------------------------------------------------------------------
;
RECIVE_CH:	
	MOV.W	F_REQ,R0			; 
	BTST	LAST_F,R0			;in the case if the data [RCVE] is received ? 
	JC	SEND_STATUS			;No->RAM_MAIN
	CMP.B	#0,data_count			;checking if the data in the buffer. 
	JZ	RAM_MAIN			;NO->RAM_MAIN
;-----------------------------------------------
	MOV.W	F_REQ,R0
	BTST	F_BIN_END,R0		;Binary data end REQ ？
	JC	NOR_RECIVE		;YES->BIN_END(ASCII data treatment section)
	MOV.W	BUFF_Flag,R0
	MOV.W	W_BUFF_NUM,R1		;
	CMP.W	#100,R1			;
	JC	CHK_BUFF_100		;
	CMP.W	#200,R1			;
	JC	CHK_BUFF_200		;
	CMP.W	#300,R1			;
	JC	CHK_BUFF_300		;
	BTST	0,R0			;Was the buffer which it was written in the last time read properly?
	JNC	NOR_RECIVE		;YES-NORMAL
	JMP	RAM_MAIN		;
CHK_BUFF_100:
	BTST	1,R0			;Was the buffer which it was written in the last time read properly?
	JNC	NOR_RECIVE		;YES-NORMAL
	JMP	RAM_MAIN		;
CHK_BUFF_200:
	BTST	2,R0		   	;Was the buffer which it was written in the last time read properly?
	JNC	NOR_RECIVE		;YES-NORMAL
	JMP	RAM_MAIN		;
CHK_BUFF_300:
	BTST	3,R0			;Was the buffer which it was written in the last time read properly?
	JNC	NOR_RECIVE		;YES-NORMAL
	JMP	RAM_MAIN		;
NOR_RECIVE:
	SUB.B	#1,data_count			;data count -1
	MOV.B	data_r_point,A0			;reading the pointer for reading 
	MOV.B	data_buff[A0],bnow_code		;form buffer to bnow_code
	ADD.B	#1,data_r_point			;
	CMP.B	#BUFF_MAX,data_r_point		;Does the pointer reach the edge ?
	JNZ	RECIVE_NOR			;NO->norma
	MOV.B	#0,data_r_point			;YES->set the pointer 0
RECIVE_NOR:	
	MOV.W	F_REQ,R0
	BTST	F_BIN_END,R0		;Is there the req for the treatment receiving  binary data end？
	JC	ASCII_ESC		;YES->BIN_END

;--------------------  check sum treatment  --------------------------
;
	MOV.B		bnow_code,R0H		; loading applicable data (receiving)
	MOV.B		bchksum_buf,R0L		; loading lower eight bits total peace
	ADD.B		R0H,R0L				;
	MOV.B		R0L,bchksum_buf		; >store all of the sum 
; ----- 2の補数 -----
	NOT.B		R0L			; reversal 
	ADD.B		#1,R0L			; 
	MOV.B		R0L,bchksum		;	
;--------------------------------------------------------------------------

ASCII_ESC:

;
;-----------------------------------------------------------------------------
;		Send data to the main buffer.
;-----------------------------------------------------------------------------
;
DATA_TO_BUFF:	
	MOV.B	bnow_code,R0L		; Is  the binary data received 1B([ESC])?
	CMP.B	#1BH,R0L		;
	JZ	CH_EACAPE		;YES->[ESC] treatment 
	MOV.W	F_REQ,R0		;
	BTST	ESC_F,R0		;once get 1B([ESC])?
	JC	CH_ESCAPE_2		;YES-[ESC] treatment 2
	JMP	RETURN_TO_D_B		;
;-----------------------------------------------------------------
;	[ESC]処理
;------------------------------------------------------------------
CH_EACAPE:
	MOV.B	bnow_code,ESC_BUFF_1	;the first data storage to buffer
	MOV.W	F_REQ,R0		;
	BSET	ESC_F,R0		;
	MOV.W	R0,F_REQ		;
	JMP	RAM_MAIN		;
CH_ESCAPE_2:
	MOV.B	bnow_code,R0L		;
	CMP.B	#51H,R0L
	JZ	ESC_SOME		;
	CMP.B	#53H,R0L		;
	JZ	ESC_SOME		;
	CMP.B	#61H,R0L		;
	JZ	ESC_SOME		;
	CMP.B	#5BH,R0L		;
	JZ	ESC_CONTINUE		;
	;JMP	RETURN_TO_D_B
	JMP	NOT_X_CONT		;in the case no flow control
ESC_CONTINUE:
	MOV.B	ESC_BUFF_1,bnow_code	;
	MOV.W	F_REQ,R0		;
	BCLR	ESC_F,R0
	MOV.W	R0,F_REQ
	JMP	RETURN_TO_D_B
ESC_SOME:
	MOV.W	F_REQ,R0
	BCLR	ESC_F,R0
	MOV.W	R0,F_REQ
	MOV.B	bnow_code,R0L		;
	SUB.B	#40H,R0L		;Convert it into normal code.
	MOV.B	R0L,bnow_code
	JMP	RETURN_TO_D_B

NOT_X_CONT:
	MOV.B	bnow_code,ESC_BUFF_1	;
	MOV.B	#1BH,bnow_code		;
	MOV.W	F_REQ,R0		;
	BCLR	ESC_F,R0		;
	BSET	F_ESC_NOR,R0		;
	MOV.W	R0,F_REQ
	JMP	RETURN_TO_D_B
NOT_X_CONT_2:
	MOV.B	ESC_BUFF_1,bnow_code
	MOV.W	F_REQ,R0		;
	BCLR	F_ESC_NOR,R0		;
	MOV.W	R0,F_REQ		;
RETURN_TO_D_B:	
	MOV.W	F_REQ,R0
	BTST	F_BIN_END,R0		;Is there REQ to end the treatment binary data?
	JC	BIN_END			;YES->BIN_END
; ----- renewal the address  & length  -----;Do address operation when get data to buffer
F_ADD_ADRESS:									
	ADD.W		#1,bdwnh_adr
	ADC.W		#0,bdwnh_adr+2
	MOV.W		bdwnh_adr,F_PAGE_AD		; > taking shelter data
	AND.W		#000FH,bdwnh_adr+2		;
	MOV.W		bdwnh_adr+2,F_BLOCK_AD		; >				;
	SUB.W		#1,wdwnh_len			;; load DWNH length -1;
;
	MOV.W	W_BUFF_NUM,R1		;Read a buffer number for writing.
	MOV.W	F_PAGE_AD,A0		; address (ML)
	AND.W	#00FFH,A0		;
	ADD.W	R1,A0
	MOV.B	bnow_code,R0L		; load the receiving fixed data
	MOV.B	R0L,F_BUFF_A[A0]	;Write data in buffer.
CH_BIN_LAST_DATA:
	MOV.W	F_PAGE_AD,BORDER_AD_ML	;				;
	MOV.W	F_BLOCK_AD,BORDER_AD_H	;For the address decision in the boundary treatment.
										;
	CMP.W	#1,wdwnh_len		;Is this the last data? 
	JNZ	CH_PAGE_LAST_DATA	;NO-> judgement the bottom data of the page 
	MOV.W	F_PAGE_AD,OLD_PAGE_AD	;storage the address of this data as OLD_AD
	MOV.W	F_BLOCK_AD,OLD_BLOCK_AD	;
	MOV.W	W_BUFF_NUM,OLD_BUFF_NUM	;
	MOV.W	F_REQ,R0		;
	BSET	F_BIN_END,R0		;the flag of ASCII data receiveing  on
	BSET	SUM_CH_F,R0		;the flag of request  to treat ment check sum data
	MOV.W	R0,F_REQ		;
;-------------------------------------------------------------------
	MOV.W	W_BUFF_NUM,R1		;read the buffer number for writng 
	MOV.W	BUFF_Flag,A0		;
	CMP.W	#100H,R1		;
	JZ	BUFF_100		;
	CMP.W	#200H,R1		;
	JZ	BUFF_200		;
	CMP.W	#300H,R1		;
	JZ	BUFF_300		;
	BSET	0,A0			;
	JMP	BUFF_ESC		;
BUFF_100:
	BSET	1,A0
	JMP	BUFF_ESC		;
BUFF_200:
	BSET	2,A0
	JMP	BUFF_ESC		;
BUFF_300:	
	BSET	3,A0
BUFF_ESC:
	MOV.W	A0,BUFF_Flag		;
	JMP	RAM_MAIN		;
;------------------------------------------------------------
CH_PAGE_LAST_DATA:			; judegememt if the data is bottom of page
	MOV.W	F_PAGE_AD,A0		;
	AND.W	#00FFH,A0		;
	CMP.W	#255,A0			; filled the page ？
	JNZ	RAM_MAIN		;NO->RAM_MAIN

	MOV.W	#PAGE_RQ,COMMAND_IN		;
	MOV.W	F_PAGE_AD,COM_AD_ML_IN		;
	MOV.W	F_BLOCK_AD,COM_AD_H_IN		;
	MOV.W	W_BUFF_NUM,COM_BUFF_NUM_IN		;
	JSR	COM_TO_BUFF			; send the command to buffer
	MOV.W	#R_ALAY_RQ,COMMAND_IN		; send the read alay command 
	MOV.W	#0FFFEH,COM_AD_ML_IN	;		;
	MOV.W	#0FH,COM_AD_H_IN		;	;
	MOV.W	W_BUFF_NUM,COM_BUFF_NUM_IN
	JSR	COM_TO_BUFF			; send the command to buffer
	
	ADD.W	#100H,W_BUFF_NUM
	CMP.W	#400H,W_BUFF_NUM
	JNZ	DETERMIN_BUFF
	MOV.W	#0,W_BUFF_NUM
DETERMIN_BUFF:
	MOV.W	W_BUFF_NUM,FF_BUFF_NUM		;
	JSR	F_FILL_BUFF_FF			;fill the buffer wih the data 0ffH 
FF_CALL:
	MOV.W	bdwnh_adr,F_PAGE_AD
	MOV.W	bdwnh_adr+2,F_BLOCK_AD
	JMP	RAM_MAIN		;->MAINLOOP					;
;*************	SUB ROUTIN   ***************************************
;
;-------------- read alay ----------------
;
CH_READ_ALEY:
	
	MOV.W	#0FFFEH,A0	; the address(H) to set read alay 
	MOV.W	#0FH,A1		; the address(ML) to set read alay 
	MOV.W	#READ_ALAY_COM,R0;
	STE.W	R0,[A1A0]	; set the read alay command
	MOV.W	COM_COUNT,R0	; command counter-1
	SUB.W	#1,R0		
	MOV.W	R0,COM_COUNT		
	
	RTS			
;
;--------------  page writing -----------
;
CH_PAGE:
	
	BCLR	1,FER			;
	BSET	1,FER			;

	SUB.W	#1,COM_COUNT		; command counter-1
	
	MOV.W	PAGE_ADR_ML,A0		;
	MOV.W	PAGE_ADR_H,A1		;
	AND.W	#0FF00H,A0		;Put a command in even-numbered address.
	MOV.W	#PAGE_COM,R0		;page program command 
	STE.W	R0,[A1A0]		;
BUFF_TO_MEMORY:	
	MOV.W	PAGE_ADR_ML,A0		;
	AND.W	#0FF00H,A0		;
	MOV.W	#0,A1			; A1 = counter
BUFF_TO_MEMORY_LOOP:

	MOV.W	R_BUFF_NUM,R1		;
	ADD.W	R1,A1			;
	MOV.W	F_BUFF_A[A1],R0		;
	SUB.W	R1,A1			;
	PUSH.W	A1			;take shelter counter
	MOV.W	PAGE_ADR_H,A1		;
	STE.W	R0,[A1A0]
	ADD.W	#2,A0			;
	POP.W	A1			;call back counter
	ADD.W	#2,A1			;
	CMP.W	#100H,A1		;
	JNZ	BUFF_TO_MEMORY_LOOP	;--->LOOP
;-----------------------------------------------------------------
	MOV.W	R_BUFF_NUM,R1		;reading buffer number 
	MOV.W	BUFF_Flag,A0		;
	CMP.W	#100H,R1		;
	JZ	BUFF_100_C		;
	CMP.W	#200H,R1		;
	JZ	BUFF_200_C		;
	CMP.W	#300H,R1		;
	JZ	BUFF_300_C		;
	BCLR	0,A0			;
	JMP	BUFF_ESC_C		;
BUFF_100_C:
	BCLR	1,A0
	JMP	BUFF_ESC_C		;
BUFF_200_C:
	BCLR	2,A0
	JMP	BUFF_ESC_C		;
BUFF_300_C:	
	BCLR	3,A0
BUFF_ESC_C:
	MOV.W	A0,BUFF_Flag		;
;--------------------------------------------------
	RTS				;

;----------fill the buffer with the data 0ffh -----------
;
;	INPUT:	FF_BUFF_NUM
;

F_FILL_BUFF_FF:
	MOV.W	#0FFFFH,R0	;the data
	MOV.W	#F_BUFF_A,A1	;
	ADD.W	FF_BUFF_NUM,A1	;destiny address 
	MOV.W	#128,R3		;
	SSTR.W			;fill the buffer with the data 0ffh
	RTS	
;
;*************   BIN DATA END ROUTIN   **********************	
;
BIN_END:
	MOV.W	F_REQ,R0
	BTST	LAST_F,R0
	JC	SEND_STATUS
	MOV.W	F_REQ,R0		; receiving flag OFF
	MOV.W	R0,F_REQ		;
	MOV.W	F_REQ,R0		;
	BTST	SUM_CH_F,R0		;now is on processing check sum ?
	JC	CHEACK_SUM_LOUTIN	;YES->check sum treatment		
	MOV.W	F_REQ,R0		;
	BTST	RCVE_CH_F,R0		;now is on treatment [RCVE] receiving ？
	JC	CHEACK_RCVE_LOUTIN	;YES->RCVE receiving check
CH_ADRESS_CH:	
	MOV.W	F_REQ,R0		; finished address treatment ?
	BTST	ADR_END,R0		;
	JC	LENGTH_LOUTIN		;YES->length treatment
;
;-------------	address judgement  ------------------------
;		
ADRESS_LOUTIN:
	MOV.W	ADR_COUNT,A0		;
	MOV.B	bnow_code,R0L		;loading receiving fixed data 		;
	MOV.B	R0L,ADRES_BUFF_F[A0]	; > address 			
	MOV.B	R0L,ASCII_BIN[A0]	;for ascii data to hex calculation	
;
	INC.W	A0			;
	MOV.W	A0,ADR_COUNT
	CMP.W	#6,A0			; adress data  receiving is finished ?
;
	JNZ	RAM_MAIN		; No->RAM_MAIN		
	MOV.W	F_REQ,R0		;
	BSET	ADR_END,R0		;the flag start address (ASCII) receiving off
	BCLR	RCVE_CH_F,R0		;request for [RCVE] receiving check off
	MOV.W	R0,F_REQ		;
	JSR	ASCII_TO_BIN		;
	FCLR	I			;to limite interrupt
	MOV.B	BIN_L,bdwnh_adr		;
	MOV.B	BIN_M,bdwnh_adr+1	;address L,M->
	MOV.B	BIN_H,bdwnh_adr+2	;address H->
	MOV.B	BIN_L,R0L		;address 
	MOV.B	BIN_M,R0H		;
	MOV.W	R0,bdwnh_adr		;
	SUB.W	#1,bdwnh_adr
	SBB.B	#0,bdwnh_adr+2
	FSET	I			;
	MOV.W	#0,ADR_COUNT		;initializaion address counter
	JMP	RAM_MAIN		;
;
;--------------	length treatment  -------------------------
;
LENGTH_LOUTIN:				;The number of the received data

	MOV.B	bnow_code,R0L		; loading the fixed data ;4byte
	MOV.W	LENGTH_COUNT,A0		; the number of length data  
	MOV.B	R0L,ASCII_BIN[A0]	; for ascii calculation
	INC.W	A0			;
	MOV.B	A0,LENGTH_COUNT
	CMP.W	#4,A0			; received 4 byte data ?
	JZ	ASCII_TO_BIN_LEN	;Y->to the end of length treatment 
	JMP	RAM_MAIN		;to RAM_MAIN
ASCII_TO_BIN_LEN:	
	JSR	ASCII_TO_BIN		;to ASCII_TO_BIN treatment
	MOV.B	BIN_M,wdwnh_len		;address L,M->,wdwnh_len
	MOV.B	BIN_H,wdwnh_len+1	
	ADD.W	#1,wdwnh_len
;
	MOV.W	F_REQ,R0		;
	BCLR	F_BIN_END,R0		;the flag ASCII data receiving 0ff
	BCLR	ADR_END,R0		;the flag address treatment is finished off	
	MOV.W	R0,F_REQ		;
	MOV.B   #0,LENGTH_COUNT		;
	MOV.W	BORDER_AD_H,R1			;test
	AND.W	#000FH,R1			;	
;--------------------------------------------------------------------
;	judge to write the same buffer as last time
;--------------------------------------------------------------------
	MOV.W	bdwnh_adr,A0			;
	MOV.W  	bdwnh_adr+2,A1			;NEW_ADR H
	ADD.W	#1,A0				;
	ADC.W	#0,A1				;
	AND.W	#000FH,A1			;
	CMP.W	R1,A1				;The comparison of the block address 
	JZ	EQUAL_AD_H			;
	MOV.W	#PAGE_RQ,COMMAND_IN		;execute page program command 
	MOV.W	OLD_PAGE_AD,COM_AD_ML_IN	;
	MOV.W	OLD_BLOCK_AD,COM_AD_H_IN	
	MOV.W	OLD_BUFF_NUM,COM_BUFF_NUM_IN	;
	JSR	COM_TO_BUFF			;
	ADD.W	#100H,W_BUFF_NUM		;advance buffer number for writing
	CMP.W	#400H,W_BUFF_NUM		;the buffer pointer is end ?
	JNZ	ADD_BUFF_NUM_D0			;NO->use next buffer
	MOV.W	#0,W_BUFF_NUM			;Yes->use first buffer
ADD_BUFF_NUM_D0:
	MOV.W	W_BUFF_NUM,FF_BUFF_NUM		;fill the used buffer with 0FFh
	JSR	F_FILL_BUFF_FF			;
	MOV.W	#R_ALAY_RQ,COMMAND_IN		;set read alay  command
	MOV.W	#0FFFEH,COM_AD_ML_IN	;		
	MOV.W	#0FH,COM_AD_H_IN		;	
	MOV.W	W_BUFF_NUM,COM_BUFF_NUM_IN
	JSR	COM_TO_BUFF			;set command to command buffer
	MOV.W	bdwnh_adr,B_IN_AD_ML
	MOV.W	bdwnh_adr+2,B_IN_AD_H
	ADD.W	#1,B_IN_AD_ML
	ADC.W	#0,B_IN_AD_H
	JMP	RAM_MAIN		

EQUAL_AD_H:
	

	MOV.W	BORDER_AD_ML,R0
	AND.W	#0FF00H,R0		;
	MOV.W	bdwnh_adr,A0		;NEW_ADR ML
	ADD.W	#1,A0			;
	AND.W	#0FF00H,A0		;
	CMP.W	A0,R0			; is the same page address ? 
	JNZ	SWICH_BUFF
	MOV.W	BUFF_Flag,A0		
	MOV.W	W_BUFF_NUM,R1
	cmp.W	#0,R1
	JNZ	NOT_Z_BUFF
	BCLR	0,A0
	JMP	END_UNCH_BUFF
NOT_Z_BUFF:
	CMP.W	#100H,R1
	JNZ	NOT_100_BUFF
	BCLR	1,A0
	JMP	END_UNCH_BUFF
NOT_100_BUFF:
	CMP.W	#200H,R1
	JNZ	NOT_200_BUFF
	BCLR	2,A0
	JMP	END_UNCH_BUFF
NOT_200_BUFF:
	BCLR	3,A0
END_UNCH_BUFF:
	MOV.W	A0,BUFF_Flag
	JMP	RAM_MAIN		;YES->don't change buffer
					;NO->change buffer
SWICH_BUFF:
	MOV.W	#PAGE_RQ,COMMAND_IN		;
	MOV.W	F_PAGE_AD,COM_AD_ML_IN		; request for page writing
	MOV.W	F_BLOCK_AD,COM_AD_H_IN		;
	MOV.W	OLD_BUFF_NUM,COM_BUFF_NUM_IN	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	JSR	COM_TO_BUFF			;
	MOV.W	#R_ALAY_RQ,COMMAND_IN		; send read alay command
;
	MOV.W	#0FFFEH,COM_AD_ML_IN	;	;
	MOV.W	#0FH,COM_AD_H_IN		
	JSR	COM_TO_BUFF			; send command to buffer
;
	ADD.W	#100H,W_BUFF_NUM		;advance the number of wrintg buffer
	CMP.W	#400H,W_BUFF_NUM		;the buffer pointer is end ？
	JNZ	ADD_BUFF_NUM0			;NO->use next buffer
	MOV.W	#0,W_BUFF_NUM
ADD_BUFF_NUM0:
	MOV.W	W_BUFF_NUM,FF_BUFF_NUM		;fill the used buffer with 0FFH
	JSR	F_FILL_BUFF_FF			;
	JMP	RAM_MAIN		
;
;-------------	check sum treatment ------------------------
;
CHEACK_SUM_LOUTIN:
	MOV.B	#30H,brtn_sts		;execute condition is normal
	MOV.W	BSUM_COUNT,A0		;
	MOV.B	bnow_code,R0L		;check sum data receiving 
	MOV.B	R0L,ASCII_BIN[A0]	;for ascii calculation
	INC.W	A0			;
	MOV.W	A0,BSUM_COUNT
	CMP.W	#2,A0			;read 2byte ？		
	JZ	ASCII_TO_BIN_SUM	;
	JMP	RAM_MAIN		;to RAM_MAIN
ASCII_TO_BIN_SUM:
	JSR	ASCII_TO_BIN		;ASCII_TO_BIN
	MOV.B	BIN_H,R0L		;check sum data
	MOV.B	bchksum,R0H		;
	CMP.B	R0L,R0H			;
	JZ	ASCII_TO_BIN_SUM_NOR	;YES->normal 
	
; ----- detect check sum ERR -----
	MOV.B		#C_CMD_ERR2,brtn_sts; ERR_2>set the executive condition
; ------------------------
ASCII_TO_BIN_SUM_NOR:
	MOV.W	F_REQ,R0		;
	BCLR	SUM_CH_F,R0
	BSET	RCVE_CH_F,R0		;set the judegement RCVE flag
	MOV.W	R0,F_REQ		;
	MOV.W	#0,BSUM_COUNT		;initialization count for check sum
	MOV.W	#0,bchksum_buf		;initialization check sum 
	JMP	RAM_MAIN		;to RAM_MAIN	
;
;-------------	Judgement RCVE	 ------------------------
;	
CHEACK_RCVE_LOUTIN:
	MOV.B	bnow_code,R0L		;
	CMP.B	#C_CMD_RCVE,R0L		; [RCVE]ｺﾏﾝﾄﾞ ?
	JZ	SEND_STATUS_OO		; --> YES (DWNH終了)
					; condition を送る	
	MOV.W	F_REQ,R0		;NO->[RCVE]チェック
	BCLR	RCVE_CH_F,R0		;要求 command をoff
	MOV.W	R0,F_REQ		;
	JMP	CH_ADRESS_CH		;address チェックへ
;
;------------- SEND STATUS	-------------------------
;
SEND_STATUS_OO:
	MOV.W	#PAGE_RQ,COMMAND_IN		;
	MOV.W	F_PAGE_AD,COM_AD_ML_IN		;
	MOV.W	F_BLOCK_AD,COM_AD_H_IN		;
	MOV.W	W_BUFF_NUM,COM_BUFF_NUM_IN
	JSR	COM_TO_BUFF			; command をbufferに送る
;	
	MOV.W	#R_ALAY_RQ,COMMAND_IN		; read alay  command を送る
	MOV.W	#0FFFEH,COM_AD_ML_IN	;		;
	MOV.W	#0FH,COM_AD_H_IN		;	;
	JSR	COM_TO_BUFF			; command をbufferに送る

SEND_STATUS:
	
	MOV.W	F_REQ,R0		;[RCVE]を受け取った後の処理
	BSET	LAST_F,R0		;
	MOV.W	R0,F_REQ		;
	MOV.W	COM_COUNT,R0		;
	CMP.W	#0,R0			;
	JNZ	RAM_MAIN		;もしも、 command が残っているなら;test

	
SEND_STATUS_0:	
.IF	POD==1	
	BTST	FER0,FER	;BUSY or READY
	JNC	SEND_STATUS_0	;BUSY->LOOP
.ENDIF

	BSET	0,0AH					;protection register
	MOV.B	#00000000B,CM1				;1 cycle
	BCLR	0,0AH
	BSET	1,0AH
	MOV.B	#00001000B,PM1
	BCLR	1,0AH			;protection register	
	
	MOV.B	#00000101B,U1MR		; stop bit1	
	;MOV.B	#00010101B,U1MR		;transmissionstop bit2
			
		;test
;
;------------	first transmission	-------------------------
;
	MOV.B	#C_CMD_START,R0L	; [START] command ;
	MOV.B	R0L,U1TB		;transmission
SEND_STATUS_1:			
	BTST	TI_U1C1			;transmission register is empty ?
	JNC	SEND_STATUS_1		;no->loop
;-------------	2回目transmission	-------------------------
;
	;MOV.B	#30H,R0L		;[Normal]  condition 
     	MOV.B	brtn_sts,R0L
	MOV.B	R0L,U1TB
SEND_STATUS_2:
	BTST	TI_U1C1			;transmission register is empty ?
	JNC	SEND_STATUS_2
;
;-------------	3rd transmission	-------------------------
;

	MOV.B	#C_CMD_END,R0L		; [END] command;
	MOV.B	R0L,U1TB		;transmission;

SEND_STATUS_3:		
	BTST	TI_U1C1			;transmission register is empty ?
	JNC	SEND_STATUS_3		;no->loop
;
;-------------	END PROCESS	-------------------------
;
THE_END_P_CH:		

THE_END_LOOP:				
.IF	POD==1
	BTST	FER0,FER		;
	JNC	THE_END_LOOP		;	
.ENDIF
	LDINTB	#MON_INTB			;
	MOV.B	#00000101B,U1MR		
	MOV.W	#0ABCDH,wrst_inf
;	BSET	PRC1
;	BSET	PM03
;	BCLR	PRC1
	NOP
	NOP
	NOP
	NOP
	NOP
	NOP
	NOP
	NOP
;	JMP.A	L_CNT_MAIN	;monitor start address 			;
	JMP.A	RESET		;
;********************************************************
;
ASCII_TO_BIN:
	MOV.B	#0,A0			;counterー
ASCII_TO_BIN_LOOP:		
	MOV.B	ASCII_BIN[A0],R0L	;
	CMP.B	#3BH,R0L		;Alphabet?
	JC	Alphabet_To_Bin		;Yes->alphabet->bin
	SUB.B	#30h,R0L		;No->number->bin
COMMON_ROUTIN:
	SHA.B	#4,R0L			;
	AND.B	#0F0H,R0L		;
	MOV.B	R0L,ASCII_BIN[A0]	;Put an even-numbered turn in BIN_L, M, H 0xH
	MOV.B	ASCII_BIN+1[A0],R0L	;
	CMP.B	#3BH,R0L		;Alphabet?
	JC	Alphabet_To_Bin2	;Yes->alphabet->bin
	SUB.B	#30H,R0L			;
COMMON_ROUTIN2:		
	AND.B	#0FH,R0L		;
	MOV.B	R0L,ASCII_BIN+1[A0]	;Put an odd number turn in ASCII_BIN 0,1,2.
	OR.B	ASCII_BIN+1[A0],ASCII_BIN[A0]
	MOV.W	ASCII_BIN[A0],BIN_H[A0]
	ADD.W	#2,A0
	CMP.W	#6,A0			;	;
	JNZ	ASCII_TO_BIN_LOOP	
	RTS				;
Alphabet_To_Bin:
	SUB.B	#37h,R0L			;
	JMP	COMMON_ROUTIN		;
Alphabet_To_Bin2:
	SUB.B	#37h,R0L			;
	JMP	COMMON_ROUTIN2		
;
;******************	Communication part	********************************
;
F_SEND:
	REIT
;
;------------------	 receiving part		-----------------------
F_RECIEVE:									;
	;LDIPL	#6			; 
	FCLR	B			; registor bank = 0
	PUSH.W	A0
F_TEST_LOOP:				;;;	
											;
	BTST	RI_U1C1			; Is there a received data？;Z=0C=1	;
	JC	F_I_HAVE_DATA		;YES->  receiving process			;
	JMP	F_TEST_LOOP							;
F_I_HAVE_DATA:									;
	MOV.B	#00000101B,U1MR	        ; stop bit1		
	ADD.B	#1,data_count		;data counter +1
	MOV.B	data_w_point,A0		;reading the pointer for writing 
	MOV.B	U1RB,data_buff[A0]	;writing to the received data to buffer
	ADD.B	#1,data_w_point		;
	CMP.B	#BUFF_MAX,data_w_point	;buffer is full ?
	JNZ	END_UART0		;NO->normal 
	MOV.B	#0,data_w_point		;
END_UART0:
	POP.W	A0
	REIT
;
;-----------------------------------------------------------------------
;		 storage command to buffer
;	INPUT:	COMMAND_IN	; storage command 
;		COM_AD_H_IN	; address of the execute command
;		COM_AD_ML_IN	; address of the execute command
;		COM_BUFF_NUM_IN	; the number of the buffer written the datas
;		WRITE_POINT	; the pointer for writing to command buffer
;			
;When it down loads in the monitor territory, 
;datas are not written in the buffer.
;-----------------------------------------------------------------------	
;

COM_TO_BUFF:
	MOV.W	COM_AD_ML_IN,A0			;
	MOV.W	COM_AD_H_IN,A1			;
	CMP.W	#0CH,A1
;	JNC	END_COM_TO_BUFF			;cast the contents in the buffer
	JNC	CAST_BUFF			;
	CMP.W	#0FH,A1				;
	JZ	COM_FXXXXH			;
	;
COM_TO_BUFF_1:					;Dispose of ; usually
	ADD.W	#1,COM_COUNT			; Every time command  are required, count rise
	MOV.W	WRITE_POINT,A0			;loading the pointer for writing 
	MOV.W	COMMAND_IN,COMMAND_BUFF[A0]	;loadiong the requested command 
						; store the command to  buffer
	MOV.W	COM_AD_ML_IN,AD_ML_BUFF[A0]	;storage address to buffer
	MOV.W	COM_AD_H_IN,AD_H_BUFF[A0]	;storage address to buffer
	MOV.W	COM_BUFF_NUM_IN,COM_NUM_BUFF[A0];storage buffer number
	ADD.W	#2,WRITE_POINT			;Advance the pointer for writing to command buffer
	CMP.W	#WRITE_MAX,WRITE_POINT		; command buffer is full? 
	JNZ	END_COM_TO_BUFF			;YES->set the pointer 0
	MOV.W	#0,WRITE_POINT
END_COM_TO_BUFF:
	RTS					;NO->return
COM_FXXXXH:
	CMP.W	#0BE00H,A0			;
	JNC	COM_TO_BUFF_1			;
	CMP.W	#0FE00H,A0			;
	;JNC	END_COM_TO_BUFF			;It isn't written if it tries to write it in the
	JNC	CAST_BUFF			;monitor territory.
	MOV.W	COM_AD_ML_IN,A0
	SUB.W	#4000H,A0
	MOV.W	A0,COM_AD_ML_IN
	JMP	COM_TO_BUFF_1
CAST_BUFF:
	MOV.W	COM_BUFF_NUM_IN,R1	;reading buffer number
	MOV.W	BUFF_Flag,A0		;
	CMP.W	#100H,R1		;
	JZ	CA_BUFF_100_C		;
	CMP.W	#200H,R1		;
	JZ	CA_BUFF_200_C		;
	CMP.W	#300H,R1		;
	JZ	CA_BUFF_300_C		;
	BCLR	0,A0			;0
	JMP	CA_BUFF_ESC_C		;
CA_BUFF_100_C:
	BCLR	1,A0
	JMP	CA_BUFF_ESC_C		;
CA_BUFF_200_C:
	BCLR	2,A0
	JMP	CA_BUFF_ESC_C		;
CA_BUFF_300_C:	
	BCLR	3,A0
CA_BUFF_ESC_C:
	MOV.W	A0,BUFF_Flag		
	JMP	END_COM_TO_BUFF
F_PROG_END: