memedit.asm

A MP3 Player Source Code, Enjoy it!

; 8051 memory editor

; This code is an original work of authorship by Paul Stoffregen
; and has been placed in the PUBLIC DOMAIN.  There is no copyright
; and no license agreement.  You may use this code in any manner
; you wish without a royalty or other conditions, even embedded in
; your own for-profit product.
;
; This code is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty
; of merchantability or fitness for a particular purpose.


.equ	locat, 0xD800		;location for these commands (usually 1000)


.equ    vtedit_key, 'F'           ;memory editor


;---------------------------------------------------------;
;                                                         ;
;                  External Memory Editor                 ;
;                                                         ;
;---------------------------------------------------------;

;register usage:
; R4,    Flags:
;         bit0: 0=display CODE memory, 1=display DATA memory
;         bit1: 0=editing disabled, 1=editing enabled
;         bit2: 0=editing in hex, 1=editing in ascii
;         bit3: 0=normal, 1=in middle of hex entry (value in r5)
; R6/R7, current memory location
;

.org	locat
.db	0xA5,0xE5,0xE0,0xA5	;signiture
.db	254,vtedit_key,0,0	;id (254=user installed command)
.db	0,0,0,0			;prompt code vector
.dB	0,0,0,0			;reserved
.db	0,0,0,0			;reserved
.db	0,0,0,0			;reserved
.db	0,0,0,0			;user defined
.db	255,255,255,255		;length and checksum (255=unused)
.db	"Memory Editor (VT100)",0

.org	locat+0x40            ;executable code begins here


	mov	r4, #0
	acall	redraw
main:
	mov	a, r4
	clr	acc.3
	mov	r4, a
main2:	acall   cin_filter
	acall	input_ck_2nd
cmd1:	cjne	a, #27, cmd2		;quit
	ajmp	quit
cmd2:	cjne	a, #11, cmd3		;up
	ajmp	cmd_up
cmd3:	cjne	a, #10, cmd4		;down
	ajmp	cmd_down
cmd4:	cjne	a, #8, cmd5		;left
	ajmp	cmd_left
cmd5:	cjne	a, #21, cmd6		;right
	ajmp	cmd_right
cmd6:	cjne	a, #12, cmd7		;redraw
	acall	redraw
	ajmp	main
cmd7:	cjne	a, #17, cmd8		;quit
	ajmp	quit
cmd8:	cjne	a, #3, cmd9		;code memory
	mov	a, r4
	anl	a, #11111110b
	mov	r4, a
	acall	cursor_home
	mov	dptr, #str_code
	acall	pstr
	acall	redraw_data
	ajmp	main
cmd9:	cjne	a, #4, cmd10		;data memory
	mov	a, r4
	orl	a, #00000001b
	mov	r4, a
	acall	cursor_home
	mov	dptr, #str_data
	acall	pstr
	acall	redraw_data
	ajmp	main
cmd10:	cjne	a, #7, cmd11		;goto memory loc
	ajmp	cmd_goto
cmd11:	cjne	a, #5, cmd12		;toggle editing
	ajmp	cmd_edit
cmd12:	cjne	a, #6, cmd13		;fill memory
	ajmp	cmd_fill
cmd13:	cjne	a, #1, cmd14		;edit in ascii
	mov	a, r4
	jnb	acc.1, main
	setb	acc.2
	mov	r4, a
	acall	erase_commands
	acall	print_commands
	acall	redraw_cursor
	ajmp	main
cmd14:	cjne	a, #24, cmd15		;edit in hex
        mov     a, r4
        jnb     acc.1, main
        clr     acc.2
        mov     r4, a
        acall   erase_commands
        acall   print_commands
        acall   redraw_cursor
        ajmp    main
cmd15:	cjne    a, #25, cmd16           ;page up
	ajmp	cmd_pgup
cmd16:	cjne    a, #26, cmd17           ;page down
	ajmp	cmd_pgdown
cmd17:


cmd_data:	;the input character wasn't any particular command, so
		;maybe it's some input data being typed for edit mode
	mov	b, a			;keep a copy of user data in b
	mov	a, r4
	jb	acc.1, cmd_data2
cmd_abort:
	ajmp	main			;ignore if not in edit mode
cmd_data2:
	jnb	acc.2, input_hex
input_ascii:
	mov	a, b
	acall	ascii_only
	cjne	a, b, cmd_abort		;check that input is an ascii char
	mov	dph, r7
	mov	dpl, r6
	;lcall	smart_wr		;write the char to memory
	movx	@dptr, a
	ajmp	cmd_right

input_hex:
	mov	a, b
	acall	upper
	acall	asc2hex
	jc	cmd_abort		;ignore if not hex
	mov	r0, a			;keep hex value of input in r0
        mov     dph, r7			;load dptr with address
        mov     dpl, r6
	mov	a, r4
	jb	acc.3, input_hex_2nd
input_hex_1st:
	mov	a, r0
	mov	r5, a
	mov	a, r4
	setb	acc.3		;remember that we're waiting for 2nd char
	mov	r4, a
	acall	redraw_cursor
	ajmp	main2
input_hex_2nd:
	mov	a, r5			;get data from memory
	swap	a			;shift nibbles
	anl	a, #11110000b		;just in case
	add	a, r0			;add in this input to lower part
	;lcall	smart_wr		;write back to memory
	movx	@dptr, a
	mov	a, r4
	clr	acc.3
	mov	r4, a
	ajmp	cmd_right

input_ck_2nd:
	;the main input routine will always call here when a new
	;byte is entered... so we can do something special if we
	;were waiting for the second character and it is not a
	;legal hex character
	push	acc
	mov	a, r4
	jb	acc.1, inck2d
	;if editing is disabled, don't do anything
	clr	acc.3
inck2b:	mov	r4, a
inck2c:	pop	acc
	ret
inck2d:	jnb	acc.3, inck2b
	;if we get here, we were actually waiting for the 2nd char
	pop	acc
	push	acc
	acall	upper
	acall	asc2hex
	jnc	inck2c		;proceed normally if it is valid
	;if we get here, we did not get a hex legal char
	pop	acc
	push	acc
	cjne	a, #esc_char, inck2e
        mov     a, r4
        clr     acc.3
        mov     r4, a
        acall   redraw_cursor
	pop	acc
	pop	acc		;don't return and do the quit cmd
	pop	acc		;just quit this entry and wait for next cmd
	ajmp	main
inck2e: mov     dph, r7                 ;load dptr with address
        mov     dpl, r6
	mov	a, r5
        ;lcall   smart_wr                ;write to memory
	movx	@dptr, a
	mov	a, r4
	clr	acc.3
	mov	r4, a
	acall	redraw_cursor
	sjmp	inck2c

; R4,    Flags:
;         bit0: 0=display CODE memory, 1=display DATA memory
;         bit1: 0=editing disabled, 1=editing enabled
;         bit2: 0=editing in hex, 1=editing in ascii
;         bit3: 0=normal, 1=in middle of hex entry (value in r5)


cmd_fill:
	mov	a, r4
	anl	a, #00000010b
	jnz	cmd_fill_ok
	ajmp	main			;don't allow if not in editing mode
cmd_fill_ok:
	acall	erase_commands
        mov     a, r4
        push    acc
	mov	dptr, #fill_prompt1
	acall	pstr
	acall	ghex16
	jc	cmd_fill_abort
	jb	psw.5, cmd_fill_abort
	mov	r0, dpl
	mov	r1, dph
	mov	dptr, #fill_prompt2
	acall	pstr
	acall	ghex16
	jc	cmd_fill_abort
	jb	psw.5, cmd_fill_abort
	mov	r4, dpl
	mov	r5, dph
	mov	dptr, #fill_prompt3
	acall	pstr
	acall	ghex
	jc	cmd_fill_abort
	jb	psw.5, cmd_fill_abort
	mov	r2, a
	mov	a, r4
	mov	r6, a
	mov	a, r5
	mov	r7, a
	pop	acc
	mov	r4, a
	mov	dpl, r0
	mov	dph, r1
	;now r4 is restored to its normal value, dptr holds the
	;first location to fill, and r6/r7 holds the last location to
	;fill, and r2 has the fill value.
cmd_fill_loop:
	mov	a, r2
	;lcall	smart_wr
	movx	@dptr, a
	mov	a, r6
	cjne	a, dpl, cmd_fill_next
	mov	a, r7
	cjne	a, dph, cmd_fill_next
	;when we get here, we're done!
	acall	erase_commands
	acall	print_commands
	acall	redraw_data
	ajmp	main
cmd_fill_next:
	inc	dptr
	sjmp	cmd_fill_loop

cmd_fill_abort:
        pop     acc
        mov     r4, a
        acall   erase_commands
        acall   print_commands
	acall	redraw_cursor
	ajmp	main

fill_prompt1:
        .db     "Fill Memory; First: ",0
fill_prompt2:
        .db     "  Last: ",0
fill_prompt3:
        .db     " with: ",0 

cmd_edit:
	acall	erase_commands
	mov	a, r4
	xrl	a, #00000010b
	mov	r4, a
        acall   print_commands
        acall   redraw_cursor
        ajmp    main

cmd_goto:
	acall	erase_commands
	mov	dptr, #goto_prompt
	acall	pstr
	mov	a, r4
	push	acc
	acall	ghex16
	pop	acc
	mov	r4, a
	jc	cmdgt_abort
	jb	psw.5, cmdgt_abort
        mov     r6, dpl
        mov     r7, dph
        acall   cursor_home
        mov     a, #20
        acall   cursor_down
	acall	print_commands
	acall	redraw_data
	ajmp	main
cmdgt_abort:
        acall   cursor_home
        mov     a, #20
        acall   cursor_down
	acall	print_commands
	acall	redraw_cursor
	ajmp	main


goto_prompt:
	.db	"Memory Location: ",0

cmd_up:
	acall	blank_it
        mov     a, r6
        clr     c
        subb    a, #16
        mov     r6, a
        mov     a, r7
        subb    a, #0
        mov     r7, a
	mov	a, r6
	cpl	a
	anl	a, #11110000b
	jz	cmd_up_scroll
        mov     a, #1
        acall   cursor_up
        acall   invert_it
        ajmp    main
cmd_up_scroll:
	acall	redraw_data
	ajmp	main

cmd_pgup:
	dec	r7
	acall	redraw_data
	ajmp	main

cmd_pgdown:
	inc	r7
	acall	redraw_data
	ajmp	main

cmd_down:
	acall	blank_it
        mov     a, r6
        add     a, #16
        mov     r6, a
        mov     a, r7
        addc    a, #0
        mov     r7, a
	mov	a, r6
	anl	a, #11110000b
	jz	cmd_down_scroll
	mov	a, #1
	acall	cursor_down
	acall	invert_it
	ajmp	main
cmd_down_scroll:
	acall	redraw_data
	ajmp	main


cmd_left:
	acall	blank_it
	mov	a, #3
	acall	cursor_left
	mov	a, r6
	clr	c
	subb	a, #1
	mov	r6, a
	mov	a, r7
	subb	a, #0
	mov	r7, a
	mov	a, r6
	orl	a, #11110000b
	cpl	a
	jz	cmdlf2
	acall	invert_it
	ajmp	main
cmdlf2:
	mov	a, r6
	cpl	a
	anl	a, #11110000b
	jz	cmd_left_scroll
	mov	a, #48
	acall	cursor_right
	mov	a, #1
	acall	cursor_up
	acall	invert_it
	ajmp	main
cmd_left_scroll:
	acall	redraw_data
	ajmp	main


cmd_right:
	acall	blank_it
	mov	a, #3
	acall	cursor_right
	mov	dpl, r6
	mov	dph, r7
	inc	dptr
	mov	r6, dpl
	mov	r7, dph
	mov	a, r6
	anl	a, #00001111b
	jz	cmdrt2
	acall	invert_it
	ajmp	main

cmdrt2:
	mov	a, r6
	anl	a, #11110000b
	jz	cmd_right_scroll
	mov	a, #48
	acall	cursor_left
	mov	a, #1
	acall	cursor_down
	acall	invert_it
	ajmp	main
cmd_right_scroll:
	acall	redraw_data
	ajmp	main



;register usage:
; R4,    Flags:
;         bit0: 0=display CODE memory, 1=display DATA memory
;         bit1: 0=editing disabled, 1=editing enabled
;         bit2: 0=editing in hex, 1=editing in ascii
;	  bit3: 0=normal, 1=in middle of hex entry (value in r5)
; R6/R7, current memory location
;


redraw:
        mov     dptr, #str_cl		;clear screen
        acall   pstr
	acall	print_title_line
	acall	newline
	acall	print_addr_line
	acall	newline
	acall	print_dash_line
        acall   newline
	mov	a, #16
	acall	cursor_down
        acall   print_dash_line
        acall   newline
        acall   print_commands
redraw_data:
	acall	cursor_home
	mov	a, #2
	acall	cursor_down
	;compute first byte address to display on the screen
	mov	dpl, #0
	mov	dph, r7
	;now display the data
	mov	r0, #16
rd2:	acall	newline
	acall	phex16
	mov	a, #':'
	acall	cout
	mov	r2, dpl
	mov	r3, dph
rd3:	acall	space
	acall	read_dptr
	acall	phex
	inc	dptr
	mov	a, dpl
	anl	a, #00001111b
	jnz	rd3
	mov	dpl, r2
	mov	dph, r3
	acall	space
	acall	space
	acall	space
rd4:	acall	read_dptr
	acall	ascii_only
	acall	cout
	inc	dptr
	mov	a, dpl
	anl	a, #00001111b
	jnz	rd4
	djnz	r0, rd2

redraw_cursor:
	acall	cursor_home
	mov	a, r6
	swap	a
	anl	a, #00001111b
	add	a, #3
	acall	cursor_down
	;make the ascii character inverse
	mov	a, r6
	anl	a, #00001111b
	add	a, #56
	acall	cursor_right
	acall	inverse_on
	acall	read_r6r7
	acall	ascii_only
	acall	cout
	acall	inverse_off

	;now make the hex value inverse
	mov	a, r6
	anl	a, #00001111b
	rl	a
	cpl	a
	add	a, #52
	acall	cursor_left
	acall	inverse_on
	acall	read_r6r7
	acall	phex
	ajmp	inverse_off


blank_it:
	mov	a, r6
	anl	a, #00001111b
	rl	a
	cpl	a
	add	a, #49
	acall	cursor_right
	acall	read_r6r7
	acall	ascii_only
	acall	cout
	mov	a, r6
	anl	a, #00001111b
	rl	a
	cpl	a
	add	a, #52
	acall	cursor_left
	acall	read_r6r7
	ajmp	phex

invert_it:
        mov     a, r6
        anl     a, #00001111b
        rl      a
        cpl     a
        add     a, #49
        acall   cursor_right
        acall   read_r6r7
        acall   ascii_only
	acall	inverse_on
        acall   cout
	acall	inverse_off
        mov     a, r6
        anl     a, #00001111b
        rl      a
        cpl     a
        add     a, #52
        acall   cursor_left
        acall   read_r6r7
	acall	inverse_on
        acall   phex
	ajmp	inverse_off