;------------------------------------------------------------------------------ ; My Monitor Program Ver 0.46 2005.01.30 by K.Ishikawa ;------------------------------------------------------------------------------ ;------------------------------------------------------------------------------ NAMEREG s0, tmp1 NAMEREG s1, tmp2 NAMEREG s2, arg1 NAMEREG s3, arg2 NAMEREG s4, adr NAMEREG s5, len NAMEREG s6, word_h NAMEREG s7, word_l ;------------------------------------------------------------------------------ CONSTANT UART_STS, 00 ; UART Status Read Port CONSTANT UART_STS_THF, 01 ; Transmitter Half Full CONSTANT UART_STS_TXF, 02 ; Transmitter FIFO Full CONSTANT UART_STS_RHF, 04 ; Receiver Half Full CONSTANT UART_STS_RXF, 08 ; Receiver FIFO Full CONSTANT UART_STS_DR, 10 ; Receiver Data Ready CONSTANT UART_RXD, 01 ; UART RX Data Read Port CONSTANT UART_TXD, 01 ; UART TX Data Write Port CONSTANT LED_OUT, 02 ; LED Output Write Port CONSTANT SEGMENT_OUT_H, 03 ; 7seg LED Output High Write Port CONSTANT SEGMENT_OUT_L, 04 ; 7seg LED Output Low Write Port CONSTANT RAM_ADDRESS_H, 05 ; RAM Address High Read/Write Port CONSTANT RAM_ADDRESS_L, 06 ; RAM Address Low Read/Write Port CONSTANT RAM_DATA, 07 ; RAM Data Read/Write Port CONSTANT STR_DAT_ADR, 20 ; String Data Adr of Scratch Pad Mem CONSTANT STR_DAT_MAXLEN, 20 ; String Data Max Length ;------------------------------------------------------------------------------ MAIN: LOAD word_h, 00 LOAD word_l, 00 CALL MEMORY_ADR_WRITE MAIN_LOOP: CALL PUT_PROMPT CALL GET_LINE CALL PROC_COMMAND JUMP MAIN_LOOP ;------------------------------------------------------------------------------ PROC_COMMAND: LOAD adr, STR_DAT_ADR CALL SKIP_SPC FETCH arg1, (adr) ADD adr, 01 CALL TO_UPPER COMPARE arg1, CH_L JUMP Z, COMMAND_LED COMPARE arg1, CH_S JUMP Z, COMMAND_SEGMENT COMPARE arg1, CH_A JUMP Z, COMMAND_ADDRESS COMPARE arg1, CH_M JUMP Z, COMMAND_MEMORY COMPARE arg1, CH_D JUMP Z, COMMAND_DUMP COMPARE arg1, CH_T JUMP Z, COMMAND_MEMTEST RETURN ;------------------------------------------------------------------------------ COMMAND_LED: CALL SKIP_SPC CALL GET_HEX2 JUMP Z, COMMAND_LED_END OUTPUT arg1, LED_OUT CALL PUT_HEX2 CALL PUT_CRLF COMMAND_LED_END: RETURN ;------------------------------------------------------------------------------ COMMAND_SEGMENT: CALL SKIP_SPC CALL GET_HEX4 OUTPUT word_h, SEGMENT_OUT_H OUTPUT word_l, SEGMENT_OUT_L CALL PUT_HEX4 CALL PUT_CRLF COMMAND_SEGMENT_END: RETURN ;------------------------------------------------------------------------------ COMMAND_ADDRESS: CALL SKIP_SPC CALL GET_HEX4 JUMP Z, COMMAND_ADDRESS_READ CALL MEMORY_ADR_WRITE COMMAND_ADDRESS_PUT: CALL PUT_HEX4 CALL PUT_CRLF RETURN COMMAND_ADDRESS_READ: CALL MEMORY_ADR_READ JUMP COMMAND_ADDRESS_PUT ;------------------------------------------------------------------------------ COMMAND_MEMORY: CALL SKIP_SPC CALL GET_HEX2 JUMP Z, COMMAND_MEMORY_READ OUTPUT arg1, RAM_DATA COMMAND_MEMORY_PUT: CALL PUT_HEX2 CALL PUT_CRLF RETURN COMMAND_MEMORY_READ: INPUT arg1, RAM_DATA JUMP COMMAND_MEMORY_PUT ;------------------------------------------------------------------------------ COMMAND_DUMP: CALL SKIP_SPC CALL GET_HEX4 JUMP Z, COMMAND_DUMP_START CALL MEMORY_ADR_WRITE COMMAND_DUMP_START: LOAD adr, 04 COMMAND_DUMP_LOOP1: LOAD len, 10 CALL MEMORY_ADR_READ CALL PUT_HEX4 LOAD arg1, CH_colon CALL SND_UART COMMAND_DUMP_LOOP2: INPUT arg1, RAM_DATA CALL PUT_HEX2 LOAD arg1, CH_SP CALL SND_UART SUB len, 01 JUMP NZ, COMMAND_DUMP_LOOP2 CALL PUT_CRLF SUB adr, 01 JUMP NZ, COMMAND_DUMP_LOOP1 COMMAND_DUMP_END: RETURN ;------------------------------------------------------------------------------ COMMAND_MEMTEST: LOAD word_h, 00 LOAD word_l, 00 CALL MEMORY_ADR_WRITE COMMAND_MEMTEST_WRITE: LOAD adr, 20 COMMAND_MEMTEST_WRITE_LOOP1: LOAD len, 00 COMMAND_MEMTEST_WRITE_LOOP2: OUTPUT len, RAM_DATA ADD len, 01 JUMP NZ, COMMAND_MEMTEST_WRITE_LOOP2 LOAD arg1, CH_comma CALL SND_UART SUB adr, 01 JUMP NZ, COMMAND_MEMTEST_WRITE_LOOP1 CALL PUT_CRLF LOAD word_h, 00 LOAD word_l, 00 CALL MEMORY_ADR_WRITE COMMAND_MEMTEST_READ: LOAD adr, 20 COMMAND_MEMTEST_READ_LOOP1: LOAD len, 00 COMMAND_MEMTEST_READ_LOOP2: INPUT arg1, RAM_DATA COMPARE arg1, len JUMP NZ, COMMAND_MEMTEST_BAD ADD len, 01 JUMP NZ, COMMAND_MEMTEST_READ_LOOP2 LOAD arg1, CH_comma CALL SND_UART SUB adr, 01 JUMP NZ, COMMAND_MEMTEST_READ_LOOP1 COMMAND_MEMTEST_OK: CALL PUT_CRLF LOAD arg1, CH_O CALL SND_UART LOAD arg1, CH_K CALL SND_UART CALL PUT_CRLF COMMAND_MEMTEST_END: RETURN COMMAND_MEMTEST_BAD: CALL PUT_CRLF LOAD arg1, CH_E CALL SND_UART LOAD arg1, CH_R CALL SND_UART LOAD arg1, CH_R CALL SND_UART CALL PUT_CRLF JUMP COMMAND_MEMTEST_END ;------------------------------------------------------------------------------ MEMORY_ADR_READ: INPUT word_h, RAM_ADDRESS_H INPUT word_l, RAM_ADDRESS_L RETURN ;------------------------------------------------------------------------------ MEMORY_ADR_WRITE: OUTPUT word_h, RAM_ADDRESS_H OUTPUT word_l, RAM_ADDRESS_L RETURN ;------------------------------------------------------------------------------ ; parameter none ; return none ; crash arg1, tmp1 PUT_CRLF: LOAD arg1, CH_CR CALL SND_UART LOAD arg1, CH_LF CALL SND_UART RETURN ;------------------------------------------------------------------------------ ; parameter none ; return none ; crash arg1, tmp1 PUT_PROMPT: LOAD arg1, CH_M CALL SND_UART LOAD arg1, CH_O CALL SND_UART LOAD arg1, CH_N CALL SND_UART LOAD arg1, CH_greater_than CALL SND_UART RETURN ;------------------------------------------------------------------------------ ; parameter word_h ... value high to put ; word_l ... value low to put ; return none ; crash arg1, arg2 PUT_HEX4: LOAD arg1, word_h CALL PUT_HEX2 LOAD arg1, word_l CALL PUT_HEX2 RETURN ;------------------------------------------------------------------------------ ; parameter arg1 ... value to put ; return none ; crash arg1, arg2 PUT_HEX2: LOAD arg2, arg1 SR0 arg1 SR0 arg1 SR0 arg1 SR0 arg1 CALL PUT_HEX1 LOAD arg1, arg2 AND arg1, 0F CALL PUT_HEX1 RETURN ;------------------------------------------------------------------------------ ; parameter arg1 ... value to put ; return none ; crash arg1 PUT_HEX1: CALL HEX_TO_CHAR CALL SND_UART RETURN ;------------------------------------------------------------------------------ ; parameter none ; return arg1 ... received strings length ; crash tmp1, tmp2, arg1 GET_LINE: LOAD adr, STR_DAT_ADR LOAD len, 00 GET_LINE_CHAR: CALL RCV_UART COMPARE arg1, CH_BS JUMP Z, GET_LINE_CHAR_BS COMPARE arg1, CH_CR JUMP Z, GET_LINE_END CALL SND_UART COMPARE len, STR_DAT_MAXLEN JUMP Z, GET_LINE_CHAR STORE arg1, (adr) ADD adr, 01 ADD len, 01 JUMP GET_LINE_CHAR GET_LINE_CHAR_BS: COMPARE len, 00 JUMP Z, GET_LINE_CHAR LOAD arg1, CH_BS CALL SND_UART LOAD arg1, CH_SP CALL SND_UART LOAD arg1, CH_BS CALL SND_UART SUB adr, 01 SUB len, 01 JUMP GET_LINE_CHAR GET_LINE_END: LOAD arg1, CH_CR STORE arg1, (adr) CALL SND_UART LOAD arg1, CH_LF CALL SND_UART LOAD arg1, len RETURN ;------------------------------------------------------------------------------ ; parameter adr ... buffer address stored strings ; return arg1 ... value ; adr ... buffer address after converting ; zero ... NZ:valid Z:invalid ; crash arg1, arg2 GET_HEX2: FETCH arg1, (adr) ADD adr, 01 CALL CHAR_TO_HEX JUMP Z, GET_HEX2_END LOAD arg2, arg1 FETCH arg1, (adr) ADD adr, 01 CALL CHAR_TO_HEX JUMP Z, GET_HEX2_OK SL0 arg2 SL0 arg2 SL0 arg2 SL0 arg2 ADD arg2, arg1 GET_HEX2_OK: LOAD arg1, arg2 OR arg2, 01 ; Clear Zero Flag GET_HEX2_END: RETURN ;------------------------------------------------------------------------------ ; parameter adr ... buffer address stored strings ; return word_l ... value low ; word_h ... value high ; adr ... buffer address after converting ; zero ... NZ:valid Z:invalid ; crash arg1, arg2 GET_HEX4: LOAD word_h, 00 LOAD word_l, 00 CALL GET_HEX4_1CHAR JUMP Z, GET_HEX4_END CALL GET_HEX4_1CHAR JUMP Z, GET_HEX4_END CALL GET_HEX4_1CHAR JUMP Z, GET_HEX4_END CALL GET_HEX4_1CHAR JUMP Z, GET_HEX4_END GET_HEX4_OK: OR arg1, 01 ; Clear Zero Flag GET_HEX4_END: RETURN GET_HEX4_1CHAR: FETCH arg1, (adr) ADD adr, 01 CALL CHAR_TO_HEX JUMP Z, GET_HEX4_SHIFT_END SL0 word_l SLA word_h SL0 word_l SLA word_h SL0 word_l SLA word_h SL0 word_l SLA word_h ADD word_l, arg1 GET_HEX4_SHIFT_OK: OR arg1, 01 GET_HEX4_SHIFT_END: RETURN ;------------------------------------------------------------------------------ ; parameter adr ... buffer address stored strings ; return adr ... new buffer address ; crash tmp1 SKIP_SPC: FETCH tmp1, (adr) COMPARE tmp1, CH_SP JUMP Z, SKIP_SPC_NEXT COMPARE tmp1, CH_comma JUMP Z, SKIP_SPC_NEXT RETURN SKIP_SPC_NEXT: ADD adr, 01 JUMP SKIP_SPC ;------------------------------------------------------------------------------ ; parameter arg1 ... character data ; return arg1 ... converted character data ; crash arg1 TO_UPPER: COMPARE arg1, 61 JUMP C, TO_UPPER_END COMPARE arg1, 7C JUMP NC, TO_UPPER_END TO_UPPER_ACT: SUB arg1, 20 TO_UPPER_END: RETURN ;------------------------------------------------------------------------------ ; parameter arg1 ... value to convert ; return arg1 ... converted character data ; zero ... NZ:valid(0-15) Z:invalid(16-255) ; crash arg1 HEX_TO_CHAR: COMPARE arg1, 10 JUMP NC, HEX_TO_CHAR_INVALID COMPARE arg1, 0A JUMP NC, HEX_TO_CHAR_AF HEX_TO_CHAR_09: ADD arg1, CH_0 RETURN HEX_TO_CHAR_AF: ADD arg1, 37 ; 'A'-0x0A RETURN HEX_TO_CHAR_INVALID: XOR arg1, arg1 ; Set Zero Flag RETURN ;------------------------------------------------------------------------------ ; parameter arg1 ... ascii code to convert ; return arg1 ... converted value ; zero ... NZ:valid('0'-'9','a'-'f','A'-'F') Z:invalid(other) ; crash none CHAR_TO_HEX: CALL TO_UPPER COMPARE arg1, 47 ; 'F'+1 JUMP NC, CHAR_TO_HEX_INVALID COMPARE arg1, 41 ; 'A' JUMP NC, CHAR_TO_HEX_AF COMPARE arg1, 3A ; '9'+1 JUMP NC, CHAR_TO_HEX_INVALID COMPARE arg1, 30 ; '0' JUMP C, CHAR_TO_HEX_INVALID CHAR_TO_HEX_09: LOAD tmp1, 30 SUB arg1, tmp1 ; '0' OR tmp1, tmp1 ; Clear Zero Flag RETURN CHAR_TO_HEX_AF: SUB arg1, 37 ; 'A'-10 RETURN CHAR_TO_HEX_INVALID: XOR arg1, arg1 ; Set Zero Flag RETURN ;------------------------------------------------------------------------------ ; parameter none ; return arg1 ... received data ; crash arg1 RCV_UART: INPUT arg1, UART_STS TEST arg1, UART_STS_DR JUMP Z, RCV_UART INPUT arg1, UART_RXD RETURN ;------------------------------------------------------------------------------ ; parameter arg1 ... send data ; return none ; crash tmp1 SND_UART: INPUT tmp1, UART_STS TEST tmp1, UART_STS_TXF JUMP NZ, SND_UART OUTPUT arg1, UART_TXD RETURN ;------------------------------------------------------------------------------ CONSTANT CH_a, 61 CONSTANT CH_b, 62 CONSTANT CH_c, 63 CONSTANT CH_d, 64 CONSTANT CH_e, 65 CONSTANT CH_f, 66 CONSTANT CH_g, 67 CONSTANT CH_h, 68 CONSTANT CH_i, 69 CONSTANT CH_j, 6A CONSTANT CH_k, 6B CONSTANT CH_l, 6C CONSTANT CH_m, 6D CONSTANT CH_n, 6E CONSTANT CH_o, 6F CONSTANT CH_p, 70 CONSTANT CH_q, 71 CONSTANT CH_r, 72 CONSTANT CH_s, 73 CONSTANT CH_t, 74 CONSTANT CH_u, 75 CONSTANT CH_v, 76 CONSTANT CH_w, 77 CONSTANT CH_x, 78 CONSTANT CH_y, 79 CONSTANT CH_z, 7A CONSTANT CH_A, 41 CONSTANT CH_B, 42 CONSTANT CH_C, 43 CONSTANT CH_D, 44 CONSTANT CH_E, 45 CONSTANT CH_F, 46 CONSTANT CH_G, 47 CONSTANT CH_H, 48 CONSTANT CH_I, 49 CONSTANT CH_J, 4A CONSTANT CH_K, 4B CONSTANT CH_L, 4C CONSTANT CH_M, 4D CONSTANT CH_N, 4E CONSTANT CH_O, 4F CONSTANT CH_P, 50 CONSTANT CH_Q, 51 CONSTANT CH_R, 52 CONSTANT CH_S, 53 CONSTANT CH_T, 54 CONSTANT CH_U, 55 CONSTANT CH_V, 56 CONSTANT CH_W, 57 CONSTANT CH_X, 58 CONSTANT CH_Y, 59 CONSTANT CH_Z, 5A CONSTANT CH_0, 30 CONSTANT CH_1, 31 CONSTANT CH_2, 32 CONSTANT CH_3, 33 CONSTANT CH_4, 34 CONSTANT CH_5, 35 CONSTANT CH_6, 36 CONSTANT CH_7, 37 CONSTANT CH_8, 38 CONSTANT CH_9, 39 CONSTANT CH_colon, 3A CONSTANT CH_semi_colon, 3B CONSTANT CH_less_than, 3C CONSTANT CH_equals, 3D CONSTANT CH_greater_than, 3E CONSTANT CH_question, 3F CONSTANT CH_SP, 20 CONSTANT CH_dollar, 24 CONSTANT CH_comma, 2C CONSTANT CH_BS, 08 CONSTANT CH_LF, 0A CONSTANT CH_CR, 0D ;----------------------------------------------------------------------------