Create A Game Of Simon In MIPS Assembly Language (Running On MARS Simulator) Assignment Solution

Instructions

Objective

Write a MIPS assignment program to create a Game of Simon in assembly language (running on MARS simulator)

Requirements and Specifications

USE MARS SIMULATOR

Higher resolution display: when configuring the display, set Unit Width = 1, Unit Height = 1,Display Width = 256, display Height = 256. Play your old game with this configuration so you can see what it did and fix your code for the new resolution.

Use previous code and add this on to it:

(Prgm 2) Next we will modify the input If the user waits too long to enter the key they should also lose the game, even if they never press another key. This means you have to poll the keyboard interface because the get char syscall will not return. It should act as if the user entered the wrong key. Finally, add interrupts instead of polling to get the user input from the keyboard simulator. This will allow the user to hit a key while you are still redrawing the screen and/or beeping. It is OK if the display lags behind the user. Inside your handler, you should put the keys entered into a queue in case they enter more than one. I suggest working on this (and verifying) separately from the rest of lab. While it will make the rest of your code simpler, once you replace the built in exception handler, broken code can be extra confusing. You should use the exceptions.s Download exceptions.sI have posted to get you started.

Bonus: Make winning “funner”. You don’t have to show fireworks on the display while playing.

Queen’s “We are the Champions” on a marimba…that would not be worth enough points for all the time it would take. There is NO extra credit if you didn't get the rest of the lab meeting specifications, so you can not punt and make up for it here.

Screenshots of output

Source Code

.data .word 0 : 40 Stack: # Status register bits EXC_ENABLE_MASK: .word 0x00000001 # Cause register bits EXC_CODE_MASK: .word 0x0000003c # Exception code bits EXC_CODE_INTERRUPT: .word 0 # External interrupt EXC_CODE_ADDR_LOAD: .word 4 # Address error on load EXC_CODE_ADDR_STORE: .word 5 # Address error on store EXC_CODE_IBUS: .word 6 # Bus error instruction fetch EXC_CODE_DBUS: .word 7 # Bus error on load or store EXC_CODE_SYSCALL: .word 8 # System call EXC_CODE_BREAKPOINT: .word 9 # Break point EXC_CODE_RESERVED: .word 10 # Reserved instruction code EXC_CODE_OVERFLOW: .word 12 # Arithmetic overflow # Status and cause register bits EXC_INT_ALL_MASK: .word 0x0000ff00 # Interrupt level enable bits EXC_INT0_MASK: .word 0x00000100 # Software EXC_INT1_MASK: .word 0x00000200 # Software EXC_INT2_MASK: .word 0x00000400 # Display EXC_INT3_MASK: .word 0x00000800 # Keyboard EXC_INT4_MASK: .word 0x00001000 EXC_INT5_MASK: .word 0x00002000 # Timer EXC_INT6_MASK: .word 0x00004000 EXC_INT7_MASK: .word 0x00008000 DigitTable: .byte ' ', 0,0,0,0,0,0,0,0,0,0,0,0 .byte '0', 0x7e,0xff,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xff,0x7e .byte '1', 0x38,0x78,0xf8,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18 .byte '2', 0x7e,0xff,0x83,0x06,0x0c,0x18,0x30,0x60,0xc0,0xc1,0xff,0x7e .byte '3', 0x7e,0xff,0x83,0x03,0x03,0x1e,0x1e,0x03,0x03,0x83,0xff,0x7e .byte '4', 0xc3,0xc3,0xc3,0xc3,0xc3,0xff,0x7f,0x03,0x03,0x03,0x03,0x03 .byte '5', 0xff,0xff,0xc0,0xc0,0xc0,0xfe,0x7f,0x03,0x03,0x83,0xff,0x7f .byte '6', 0xc0,0xc0,0xc0,0xc0,0xc0,0xfe,0xfe,0xc3,0xc3,0xc3,0xff,0x7e .byte '7', 0x7e,0xff,0x03,0x06,0x06,0x0c,0x0c,0x18,0x18,0x30,0x30,0x60 .byte '8', 0x7e,0xff,0xc3,0xc3,0xc3,0x7e,0x7e,0xc3,0xc3,0xc3,0xff,0x7e .byte '9', 0x7e,0xff,0xc3,0xc3,0xc3,0x7f,0x7f,0x03,0x03,0x03,0x03,0x03 .byte '+', 0x00,0x00,0x00,0x18,0x18,0x7e,0x7e,0x18,0x18,0x00,0x00,0x00 .byte '-', 0x00,0x00,0x00,0x00,0x00,0x7e,0x7e,0x00,0x00,0x00,0x00,0x00 .byte '*', 0x00,0x00,0x00,0x66,0x3c,0x18,0x18,0x3c,0x66,0x00,0x00,0x00 .byte '/', 0x00,0x00,0x18,0x18,0x00,0x7e,0x7e,0x00,0x18,0x18,0x00,0x00 .byte '=', 0x00,0x00,0x00,0x00,0x7e,0x00,0x7e,0x00,0x00,0x00,0x00,0x00 .byte 'A', 0x18,0x3c,0x66,0xc3,0xc3,0xc3,0xff,0xff,0xc3,0xc3,0xc3,0xc3 .byte 'B', 0xfc,0xfe,0xc3,0xc3,0xc3,0xfe,0xfe,0xc3,0xc3,0xc3,0xfe,0xfc .byte 'C', 0x7e,0xff,0xc1,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc1,0xff,0x7e .byte 'D', 0xfc,0xfe,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xfe,0xfc .byte 'E', 0xff,0xff,0xc0,0xc0,0xc0,0xfe,0xfe,0xc0,0xc0,0xc0,0xff,0xff .byte 'F', 0xff,0xff,0xc0,0xc0,0xc0,0xfe,0xfe,0xc0,0xc0,0xc0,0xc0,0xc0 # add additional characters here.... # first byte is the ascii character # next 12 bytes are the pixels that are "on" for each of the 12 lines .byte 0, 0,0,0,0,0,0,0,0,0,0,0,0 prompt_lvl: .asciiz "Level? " bad_lvl: .asciiz "\nLevel must be between 1 and 3\n" win_msg: .asciiz "You win" lose_msg: .asciiz "You lose" ready: .asciiz "Ready..." prompt: .asciiz "Input?: " spaces: .asciiz "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n" seq: .word 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 # array to hold sequence color_table: .word 0x000000 #black .word 0x0000ff #blue .word 0x00ff00 #green .word 0xff0000 #red .word 0x00ffff #blue + green cyan .word 0xff00ff #blue + red magenta .word 0xffff00 #green + red yellow .word 0x4AABE5 #light blue .word 0x5AB661 #light green .word 0xDD3A35 #light red .word 0xEC6D2D #orange .word 0xffffff #white box_table: .byte 128, 64, 10, 20, 52 # position of box 1, orange, radius 20, E1 .byte 64, 128, 7, 20, 61 # position of box 2, blue, radius 20, C# .byte 192, 128, 9, 20, 64 # position of box 3, red, radius 20, E2 .byte 128, 192, 8, 20, 69 # position of box 4, green, radius 20, A level_len: .byte 5, 8, 11 # sequence lengths for all levels cross_tab: .byte 50, 50, 156, 0 .byte 51, 50, 155, 0 .byte 50, 51, 155, 0 .byte 50, 50, 156, 1 .byte 51, 50, 155, 1 .byte 50, 51, 155, 1 char_queue: .byte 0 : 256 queue_start: .word 0 queue_end: .word 0 .text .globl main main: la $sp, Stack jal init # initialize game li $s0, 0 # max = 0 la $s1, seq # point to start of sequence jal read_level # read the level move $a0, $v0 # convert to sequence length jal level_seq_len # get sequence length move $s2, $v0 # save in $s2 game_loop: # generate number li $a0, 4 # generate a number between 0 and 3 jal random # generate the number addi $a0, $a0, 1 # add 1 to start from 1 # add to sequence sw $a0, 0($s1) # save random number in sequence addiu $s1, $s1, 4 # advance position in sequence addiu $s0, $s0, 1 # increment max # show sequence la $a0, seq # point to start of sequence move $a1, $s0 # pass max as the sequence size jal show_sequence # show the current sequence # get user sequence la $a0, seq # point to start of sequence move $a1, $s0 # pass max as the sequence size jal get_sequence # show the current sequence beqz $v0, fail # if user failed, end loop blt $s0, $s2, game_loop # if sequence was correct and max<5, repeat loop win: li $a0, 2 # use green jal draw_cross # draw the cross # display win la $a0, win_msg # load address of win message jal put_string j exit # exit program fail: li $a0, 3 # use red jal draw_cross # draw the cross # display lose la $a0, lose_msg # load address of lose message jal put_string exit: li $v0, 10 # syscall to exit program syscall # exit the program #------------------------------------------------------------------------------ # Procedure to initialize the game # init: addi $sp, $sp, -8 # allocate space in stack to save registers sw $ra, 0($sp) # save $ra sw $s0, 4($sp) # save $s0 # get current time li $v0, 30 # syscall to get time syscall # get current time #initialize random seed using the current time move $a1, $a0 # use the time value (low part) li $a0, 0 # set generator id li $v0, 40 # syscall to set seed syscall # set the seed # Enable interrupts in status register mfc0 $t0, $12 # Disable all interrupt levels lw $t1, EXC_INT_ALL_MASK not $t1, $t1 and $t0, $t0, $t1 # Enable console interrupt levels lw $t1, EXC_INT3_MASK or $t0, $t0, $t1 #lw $t1, EXC_INT4_MASK #or $t0, $t0, $t1 # Enable exceptions globally lw $t1, EXC_ENABLE_MASK or $t0, $t0, $t1 mtc0 $t0, $12 # Enable keyboard interrupts li $t0, 0xffff0000 # Receiver control register li $t1, 0x00000002 # Interrupt enable bit sw $t1, ($t0) li $t1, 0x00000001 # ready enable bit sw $t1, 8($t0) jal clear_disp # clear the display li $a0, 11 # use white jal draw_cross # draw the cross li $a0, 12 # clear display jal put_char li $s0, 1 show_loop: move $a0, $s0 # load element from sequence li $a1, 1 # use color li $a2, 1 # use sound jal draw_box_n # draw box # pause li $a0, 300 # wait for given time jal pause # pause addi $s0, $s0, 1 ble $s0, 4, show_loop # pause li $a0, 500 # wait for given time jal pause # pause li $s0, 1 del_loop: move $a0, $s0 # load element from sequence li $a1, 0 # erase jal draw_box_n # draw box addi $s0, $s0, 1 ble $s0, 4, del_loop lw $ra, 0($sp) # load $ra lw $s0, 4($sp) # load $s0 addi $sp, $sp, 8 # remove allocated space from stack jr $ra # return to caller #------------------------------------------------------------------------------ # Procedure to pause by a number of milliseconds # On entry: $a0 = number of milliseconds to pause pause: move $t0, $a0 # save number of milliseconds # get current time li $v0, 30 # syscall to get time syscall # get current time move $t1, $a0 # save low part of current time ploop: syscall # get current time again subu $t2, $a0, $t1 # get elapsed time bltu $t2, $t0, ploop # if elapsed time < pause, repeat loop jr $ra # return to caller #------------------------------------------------------------------------------ # Procedure to get a random number in a range # On entry: $a0 = upper bound of range # On return: $v0 = random number random: move $a1, $a0 # use argument for the upper bound li $a0, 0 # generator id li $v0, 42 # syscall to generate a random number in a range syscall # generate the random number move $v0, $a0 # return generated number jr $ra # return to caller #------------------------------------------------------------------------------ # Procedure to draw a filled box by number and blink it with the given delay # On entry: $a0 = box number (1-4), $a1 = blink delay, $a2 = 0 no sound, 1 = sound, # $a3 = wait at the end # -1 = error sound blink_box_n: addi $sp, $sp, -16 # allocate space in stack to save registers sw $ra, 0($sp) # save return address in stack sw $s0, 4($sp) # save $s0 in stack sw $s1, 8($sp) # save $s1 in stack sw $s2, 12($sp) # save $s2 in stack move $s0, $a0 # save arguments move $s1, $a1 move $s2, $a3 li $a1, 1 # use color jal draw_box_n # draw box # pause move $a0, $s1 # wait for given time jal pause # pause move $a0, $s0 # load element li $a1, 0 # erase li $a2, 0 # no sound jal draw_box_n # draw box li $a0, 12 jal put_char beqz $s2, bb_end # pause srl $a0, $s1, 1 # wait for given time jal pause # pause bb_end: lw $ra, 0($sp) # load return address from stack lw $s0, 4($sp) # load $s0 from stack lw $s1, 8($sp) # load $s1 from stack lw $s2,12($sp) # load $s2 from stack addi $sp, $sp, 16 # remove allocated space from stack jr $ra # return to caller #------------------------------------------------------------------------------ # Procedure to show the current sequence # On entry: $a0 = pointer to sequence array, $a1 = sequence size show_sequence: addi $sp, $sp, -12 # allocate space in stack to save registers sw $ra, 0($sp) # save return address in stack sw $s0, 4($sp) # save $s0 in stack sw $s1, 8($sp) # save $s1 in stack move $s0, $a0 # load sequence pointer move $s1, $a1 # load sequence size # display ready message li $a0, 12 jal put_char la $a0, ready # load address of ready message jal put_string # pause li $a0, 1000 # wait for 1s jal pause # pause # print newlines to clear screen li $a0, 12 jal put_char # blink lights to show sequence seq_loop: # print number lw $a0, 0($s0) # load element from sequence addi $a0, $a0, 48 jal put_char t lw $a0, 0($s0) # load element from sequence li $a1, 1100 # wait for 1.5s li $a2, 1 # use sound li $a3, 1 jal blink_box_n # print newlines li $a0, 12 jal put_char addi $s0, $s0, 4 # advance to next element addi $s1, $s1, -1 # decrement size bne $s1, $zero, seq_loop # repeat while not zero lw $ra, 0($sp) # load return address from stack lw $s0, 4($sp) # load $s0 from stack lw $s1, 8($sp) # load $s1 from stack addi $sp, $sp, 12 # remove allocated space from stack jr $ra # return to caller #------------------------------------------------------------------------------ # Procedure to get user sequence and compare to the current sequence # On entry: $a0 = pointer to sequence array, $a1 = sequence size # On return: $v0 = 1 if the used entered the sequence correctly, 0 otherwise get_sequence: addi $sp, $sp, -16 # allocate space in stack to save registers sw $ra, 0($sp) # save return address in stack sw $s0, 4($sp) # save $s0 in stack sw $s1, 8($sp) # save $s1 in stack sw $s2, 12($sp) # save $s1 in stack move $s0, $a0 # load sequence pointer move $s1, $a1 # load sequence size jal flush_queue # remove previous chars get_loop: # display prompt la $a0, prompt # load address of prompt message jal put_string # read number li $a0, 3000 # wait at most 3 s jal get_char addi $s2, $v0, -48 # convert ascii to number # print newline li $a0, 10 # newline char jal put_char move $a0, $s2 # load element input li $a1, 500 # wait for .5s li $a2, 1 # use sound li $a3, 0 lw $t0, 0($s0) # load element from sequence beq $a0, $t0, skip # if the numbers are different, play error li $a2, -1 skip: jal blink_box_n lw $t2, 0($s0) # load element from sequence bne $t2, $s2, seq_fail # if the numbers are different, end with failure addi $s0, $s0, 4 # advance to next element addi $s1, $s1, -1 # decrement size bne $s1, $zero, get_loop # repeat while not zero li $v0, 1 # set 1 to indicate success j get_end # return seq_fail: # blink correct position lw $a0, 0($s0) # load element from sequence li $a1, 700 # wait for 1s li $a2, 0 jal blink_box_n lw $a0, 0($s0) # load element from sequence li $a1, 700 # wait for 1s li $a2, 0 jal blink_box_n li $v0, 0 # return 0 to indicate it failed get_end: lw $ra, 0($sp) # load return address from stack lw $s0, 4($sp) # load $s0 from stack lw $s1, 8($sp) # load $s1 from stack lw $s2,12($sp) # load $s1 from stack addi $sp, $sp, 16 # remove allocated space from stack jr $ra # return to caller #------------------------------------------------------------------------------ # Procedure to calculate pixel address # On entry: $a0 = x coord (0-255), $a1 = y coord (0-255) # On return: $v0 = memory address calc_addr: lui $v0, 0x1004 # load base address sll $t0, $a1, 8 # multiply y * 256 add $t0, $t0, $a0 # add y*256 + x sll $t0, $t0, 2 # multiply by 4 add $v0, $v0, $t0 # add 4*(y*256 + x) + base jr $ra # return to caller #------------------------------------------------------------------------------ # Procedure to lookup color number # On entry: $a2 = color number # On return: $v1 = number to write to display get_color: la $t0, color_table # load color table address sll $t1, $a2, 2 # multiply by 4 add $t0, $t0, $t1 # add to base address lw $v1, 0($t0) # load color jr $ra # return to caller #------------------------------------------------------------------------------ # Procedure to draw a dot # On entry: $a0 = x coordinate (0-31), $a1 = y coordinate (0-31), $a2 = color number (0-7) draw_dot: addi $sp, $sp, -4 # allocate space in stack to save registers sw $ra, 0($sp) # save $ra jal calc_addr # get pixel address jal get_color # load color sw $v1, 0($v0) # save pixel lw $ra, 0($sp) # load $ra addi $sp, $sp, 4 # remove allocated space from stack jr $ra # return to caller #------------------------------------------------------------------------------ # Procedure to draw a horizontal line # On entry: $a0 = x coordinate (0-31), $a1 = y coordinate (0-31), $a2 = color number (0-7) # $a3 = length of the line (1-32) horz_line: addi $sp, $sp, -12 # allocate space in stack to save registers sw $ra, 0($sp) # save $ra sw $a0, 4($sp) # save $a0 sw $a3, 8($sp) # save $a3 horz_loop: jal draw_dot # draw pixel addi $a0, $a0, 1 # increment x addi $a3, $a3, -1 # decrement length bnez $a3, horz_loop # repeat while not zero lw $ra, 0($sp) # load $ra lw $a0, 4($sp) # load $a0 lw $a3, 8($sp) # load $a3 addi $sp, $sp, 12 # remove allocated space from stack jr $ra # return to caller #------------------------------------------------------------------------------ # Procedure to draw a vertical line # On entry: $a0 = x coordinate (0-31), $a1 = y coordinate (0-31), $a2 = color number (0-7) # $a3 = length of the line (1-32) vert_line: addi $sp, $sp, -12 # allocate space in stack to save registers sw $ra, 0($sp) # save $ra sw $a1, 4($sp) # save $a1 sw $a3, 8($sp) # save $a3 vert_loop: jal draw_dot # draw pixel addi $a1, $a1, 1 # increment y addi $a3, $a3, -1 # decrement length bnez $a3, vert_loop # repeat while not zero lw $ra, 0($sp) # load $ra lw $a1, 4($sp) # load $a1 lw $a3, 8($sp) # load $a3 addi $sp, $sp, 12 # remove allocated space from stack jr $ra # return to caller #------------------------------------------------------------------------------ # Procedure to draw a filled box # On entry: $a0 = x coordinate (0-31), $a1 = y coordinate (0-31), $a2 = color number (0-7) # $a3 = size of the box (1-32) draw_box: addi $sp, $sp, -8 # allocate space in stack to save registers sw $ra, 0($sp) # save $ra sw $s0, 4($sp) # save $s0 move $s0, $a3 # save size box_loop: jal horz_line # draw line addi $a1, $a1, 1 # increment y addi $s0, $s0, -1 # decrement size bnez $s0, box_loop # repeat while not zero lw $ra, 0($sp) # load $ra lw $s0, 4($sp) # load $s0 addi $sp, $sp, 8 # remove allocated space from stack jr $ra # return to caller #------------------------------------------------------------------------------ # Procedure to clear the display clear_disp: lui $t0, 0x1004 # load base address li $t1, 0x10000 # 256*256 clr_loop: sw $zero, 0($t0) # save pixel 0 addi $t0, $t0, 4 # advance to next pixel addi $t1, $t1, -1 # repeat for all display bnez $t1, clr_loop jr $ra # return to caller #------------------------------------------------------------------------------ # Procedure to draw a filled box by number # On entry: $a0 = box number (1-4), $a1 = 0 to use black, 1 = to use table color # $a2 = 1 use sound, 0=no sound, -1 incorrect sound draw_box_n: addi $sp, $sp, -16 # allocate space in stack to save registers sw $ra, 0($sp) # save $ra sw $s0, 4($sp) # save $s0 sw $s1, 8($sp) # save $s1 sw $s2,12($sp) # save $s2 move $s0, $a0 move $s2, $a2 la $t0, box_table # load address of box table blt $a0, 1, chk_snd # if incorrect number, only play sound bgt $a0, 4, chk_snd addi $t1, $a0, -1 # decrement to get 0-3 sll $t2, $t1, 2 # multiply box by 5 add $t1, $t1, $t2 add $s1, $t0, $t1 # get address of box data beqz $a1, clear_box # if erasing, skip to draw box lbu $a0, 0($s1) # x lbu $a1, 1($s1) # y lbu $a2, 3($s1) # radius lbu $a3, 2($s1) # else set color from table jal draw_circle # draw circle lbu $t0, 3($s1) # radius lbu $a0, 0($s1) # x addi $a0, $a0, -5 # x - 5 lbu $a1, 1($s1) # y addi $a1, $a1, -6 # y - 6 addi $a2, $s0, 48 # number lbu $a3, 2($s1) # color from table jal out_char chk_snd: beqz $s2, db_end # if no sound, end bltz $s2, play_err # if error play error lbu $a0, 4($s1) # load note for box li $a1, 500 # duration in milliseconds li $a2, 80 # instrument j play_snd play_err: li $a0, 36 # else, load note for error li $a1, 700 # duration in milliseconds li $a2, 64 # instrument play_snd: li $v0, 31 li $a3, 120 # volume syscall # play the tone j db_end clear_box: lbu $t1, 3($s1) # radius lbu $a0, 0($s1) # x - radius sub $a0, $a0, $t1 lbu $a1, 1($s1) # y - radius sub $a1, $a1, $t1 li $a2, 0 # black sll $a3, $t1, 1 # radius * 2 + 1 add $a3, $a3, 1 jal draw_box # draw box db_end: lw $ra, 0($sp) # load $ra lw $s0, 4($sp) # load $s0 lw $s1, 8($sp) # load $s1 lw $s2,12($sp) # load $s2 addi $sp, $sp, 16 # remove allocated space from stack jr $ra # return to caller #------------------------------------------------------------------------------ # Procedure to read game level # On return: $v0 = level 1-3 read_level: addi $sp, $sp, -4 sw $ra, 0($sp) # display prompt for level la $a0, prompt_lvl # load address of prompt message jal put_string # read level li $a0, 0 # no timeout jal get_char addi $v0, $v0, -48 slti $t0, $v0, 1 # if level < 1 bnez $t0, error # print an error slti $t0, $v0, 4 # if level < 4 bnez $t0, lvl_ok # return level error: # display error la $a0, bad_lvl # load address of error message jal put_string j read_level lvl_ok: lw $ra, 0($sp) addi $sp, $sp, 4 jr $ra # return to caller #------------------------------------------------------------------------------ # Procedure to get sequence length for a given level # On entry: $a0 = level 1 - 3 # On return: $v0 = sequence length for level level_seq_len: addi $a0, $a0, -1 # get level -1 la $t0, level_len # load level length table add $t0, $t0, $a0 # get address of length lb $v0, 0($t0) # load level length jr $ra # return to caller #------------------------------------------------------------------------------ # out_char: display an ascii character in white on the bit mapped display # $a0 = horizontal pixel co-ordinate (0-255) # $a1 = vertical pixel co-ordinate (0-255) # $a2 = character # $a3 = background color out_char: addiu $sp, $sp, -24 sw $ra, 20($sp) la $t3, DigitTable # find the character in the table _text0: lb $t1, 0($t3) # get an entry from the table beq $t1, $a2, _text1 beq $t1, $zero, _text1 addiu $t3, $t3, 13 # go to the next entry in the table j _text0 _text1: move $a2, $a3 jal get_color # load color move $a3, $v1 la $t9, 0x10040000 # get the memory start address sll $t0, $a1, 8 # (a1 * 256) addu $t0, $t0, $a0 sll $t0, $t0, 2 addu $t9, $t9, $t0 # t9 = memory address for this pixel li $t8, 1 # line number in the digit array (1-12) addu $t3, $t3, 1 # advance to start of char bits _text2: lb $t4, 0($t3) # bit map to be displayed sw $a3, 0($t9) # first pixel is black addiu $t9, $t9, 4 li $t5, 8 # 8 bits to go out _text3: move $t7, $a3 andi $t6, $t4, 0x80 # mask out the bit (0=black, 1=white) beq $t6, $zero, _text4 li $t7, 0xffffff _text4: sw $t7, 0($t9) # write the pixel color addiu $t9, $t9, 4 # go to the next memory position sll $t4, $t4, 1 # and line number addiu $t5, $t5, -1 # and decrement down (8,7,...0) bne $t5, $zero, _text3 sw $a3, 0($t9) # last pixel is black addiu $t9, $t9, 4 addiu $t9, $t9, 984 # advance to the next line addu $t3, $t3, 1 # advance char line addiu $t8, $t8, 1 # increment the digit array offset (1-12) bne $t8, 13, _text2 lw $ra, 20($sp) addiu $sp, $sp, 24 jr $ra #------------------------------------------------------------------------------ # Procedure to draw a filled circle # On entry: $a0 = x, $a1 = y, $a2 = r, $a3 = color draw_circle: addi $sp, $sp, -24 sw $ra, 0($sp) sw $s0, 4($sp) sw $s1, 8($sp) sw $s2, 12($sp) sw $s3, 16($sp) sw $s4, 20($sp) move $s0, $a2 # x = radius li $s1, 0 # y = 0 sll $t0, $a2, 1 # radius*2 li $s2, 1 sub $s2, $s2, $t0 # xChange = 1 - (radius *2) li $s3, 0 # yChange = 0 li $s4, 0 # radiusError = 0 move $t5, $a0 # preserve x0 and y0 arguments move $t6, $a1 move $a2, $a3 # copy color to $a2 circ_loop: # while (x >= y) blt $s0, $s1, circ_end neg $t7, $s0 # i = -x for1: # for (int i = - x; i <= x; i++) bgt $t7, $s0, for1_end add $a0, $t5, $t7 add $a1, $t6, $s1 jal draw_dot # set_pixel (x0 + i, y0 + y,color); add $a0, $t5, $t7 sub $a1, $t6, $s1 jal draw_dot # set_pixel (x0 + i, y0 - y,color); addi $t7, $t7, 1 # i++ j for1 for1_end: beq $s0, $s1, for2_end neg $t7, $s1 # i = - y for2: # for (int i = - y; i <= y; i++) bgt $t7, $s1, for2_end add $a0, $t5, $t7 add $a1, $t6, $s0 jal draw_dot # set_pixel (x0 + i, y0 + x,color); add $a0, $t5, $t7 sub $a1, $t6, $s0 jal draw_dot # set_pixel (x0 + i, y0 - x,color); addi $t7, $t7, 1 # i++ j for2 for2_end: addi $s1, $s1, 1 # y++ add $s4, $s4, $s3 # radiusError += yChange add $s3, $s3, 2 # yChange += 2 # if (((radiusError << 1) + xChange) > 0) sll $t0, $s4, 1 # radiusError *2 add $t0, $t0, $s2 # radiusError *2 + xChange blez $t0, circ_loop addi $s0, $s0, -1 # x-- add $s4, $s4, $s2 # radiusError += xChange addi $s2, $s2, 2 # xChange += 2; j circ_loop circ_end: lw $ra, 0($sp) lw $s0, 4($sp) lw $s1, 8($sp) lw $s2, 12($sp) lw $s3, 16($sp) lw $s4, 20($sp) addi $sp, $sp, 24 jr $ra #------------------------------------------------------------------------------ # Procedure to draw a white diagonal # On entry: $a0 = x, $a1 = y, $a2 = length, $a3 = 0 if normal, 1 if inverted # on stack = color draw_diag: addi $sp, $sp, -20 # allocate space in stack to save registers sw $ra, 0($sp) # save $ra sw $s0, 4($sp) # save $s0 sw $s1, 8($sp) # save $s1 sw $s2,12($sp) # save $s2 sw $s3,16($sp) # save $s3 move $s0, $a0 # initial position x move $s1, $a1 # initial position y li $s2, 1 # increment move $s3, $a2 # load length beqz $a3, diag_loop li $t0, 256 sub $s0, $t0, $s0 # invert x li $s2, -1 # decrement diag_loop: move $a0, $s0 # x move $a1, $s1 # y lw $a2, 20($sp) # load color jal draw_dot # draw dot add $s0, $s0, $s2 # x+= inc add $s1, $s1, 1 # y++ addiu $s3, $s3, -1 # len-- bnez $s3, diag_loop lw $ra, 0($sp) # load $ra lw $s0, 4($sp) # load $s0 lw $s1, 8($sp) # load $s1 lw $s2,12($sp) # load $s2 lw $s3,16($sp) # load $s3 addi $sp, $sp, 20 # remove allocated space from stack jr $ra #------------------------------------------------------------------------------ # Procedure to draw a cross # Receives: $a0 = color draw_cross: addi $sp, $sp, -12 # allocate space in stack to save registers sw $ra, 0($sp) # save $ra sw $s0, 4($sp) # save $s0 sw $s1, 8($sp) # save $s1 addi $sp, $sp, -4 # save color arg sw $a0, 0($sp) la $s0, cross_tab # point to cross table li $s1, 6 # draw 6 diagonals cross_loop: lbu $a0, 0($s0) # initial position x lbu $a1, 1($s0) # initial position y lbu $a2, 2($s0) # length lbu $a3, 3($s0) # direction jal draw_diag # draw diagonal addi $s0, $s0, 4 # advance to next entry addi $s1, $s1, -1 # decrement number bnez $s1, cross_loop # repeat while not zero addi $sp, $sp, 4 # remove color lw $ra, 0($sp) # load $ra lw $s0, 4($sp) # load $s0 lw $s1, 8($sp) # load $s1 addi $sp, $sp, 12 # remove allocated space from stack jr $ra #------------------------------------------------------------------------------ # Procedure to read a character using interrupts, echoes char on console # Receives: $a0 = 0 if normal read, > 0 timeout # Returns: $v0 = character read, or -1 if timeout get_char: addi $sp, $sp, -12 # allocate space in stack to save registers sw $ra, 0($sp) # save $ra sw $s0, 4($sp) # save $s0 sw $s1, 8($sp) # save $s1 move $s0, $a0 # save argument # get current time li $v0, 30 # syscall to get time syscall # get current time move $s1, $a0 # save low part of current time la $t0, char_queue # load queue address la $t1, queue_start # load queue start index lw $t2, 0($t1) # load start of queue add $t0, $t0, $t2 # add to base address la $t3, queue_end # load queue end gc_loop: beqz $s0, notime # if no timeout enabled, skip li $v0, 30 # syscall to get time syscall # get current time again subu $t4, $a0, $s1 # get elapsed time bgeu $t4, $s0, gc_tout # if elapsed time > timeout, return notime: lw $t4, 0($t3) # load end beq $t4, $t2, gc_loop # if no chars, wait lb $s0, 0($t0) # load character addi $t2, $t2, 1 # increment start of queue andi $t2, $t2, 255 # wrap around if > 256 sw $t2, 0($t1) move $a0, $s0 # echo on console jal put_char move $v0, $s0 # return char j gc_end gc_tout: li $v0, -1 # timed out gc_end: lw $ra, 0($sp) # load $ra lw $s0, 4($sp) # load $s0 lw $s1, 8($sp) # load $s1 addi $sp, $sp, 12 # remove allocated space from stack jr $ra #------------------------------------------------------------------------------ # Procedure to print a character # Receives: $a0 = character to print put_char: li $t0, 0xffff0008 pc_loop: lw $t1, 0($t0) # load status andi $t1, $t1, 1 # test ready bit beqz $t1, pc_loop # if not ready, wait sw $a0, 4($t0) # save character jr $ra #------------------------------------------------------------------------------ # Procedure to print a string # Receives: $a0 = address of string to print put_string: addi $sp, $sp, -8 # allocate space in stack to save registers sw $ra, 0($sp) # save $ra sw $s0, 4($sp) # save $s0 move $s0, $a0 # copy string address ps_loop: lb $a0, 0($s0) # load character from string beqz $a0, ps_end # if null, end print jal put_char # else, print character addi $s0, $s0, 1 # advance to next char j ps_loop ps_end: lw $ra, 0($sp) # load $ra lw $s0, 4($sp) # load $s0 addi $sp, $sp, 8 # remove allocated space from stack jr $ra #------------------------------------------------------------------------------ # Procedure to reset input queue flush_queue: la $t0, queue_start # load queue start index la $t1, queue_end # load queue end lw $t2, 0($t1) # load end of queue sw $t2, 0($t0) # save as start of queue jr $ra ######################################################################## # Description: # Example SPIM exception handler # Derived from the default exception handler in the SPIM S20 # distribution. # # History: # Dec 2009 J Bacon ######################################################################## # Exception handling code. This must go first! .kdata __start_msg_: .asciiz " Exception " __end_msg_: .asciiz " occurred and ignored\n" # Messages for each of the 5-bit exception codes __exc0_msg: .asciiz " [Interrupt] " __exc1_msg: .asciiz " [TLB]" __exc2_msg: .asciiz " [TLB]" __exc3_msg: .asciiz " [TLB]" __exc4_msg: .asciiz " [Address error in inst/data fetch] " __exc5_msg: .asciiz " [Address error in store] " __exc6_msg: .asciiz " [Bad instruction address] " __exc7_msg: .asciiz " [Bad data address] " __exc8_msg: .asciiz " [Error in syscall] " __exc9_msg: .asciiz " [Breakpoint] " __exc10_msg: .asciiz " [Reserved instruction] " __exc11_msg: .asciiz "" __exc12_msg: .asciiz " [Arithmetic overflow] " __exc13_msg: .asciiz " [Trap] " __exc14_msg: .asciiz "" __exc15_msg: .asciiz " [Floating point] " __exc16_msg: .asciiz "" __exc17_msg: .asciiz "" __exc18_msg: .asciiz " [Coproc 2]" __exc19_msg: .asciiz "" __exc20_msg: .asciiz "" __exc21_msg: .asciiz "" __exc22_msg: .asciiz " [MDMX]" __exc23_msg: .asciiz " [Watch]" __exc24_msg: .asciiz " [Machine check]" __exc25_msg: .asciiz "" __exc26_msg: .asciiz "" __exc27_msg: .asciiz "" __exc28_msg: .asciiz "" __exc29_msg: .asciiz "" __exc30_msg: .asciiz " [Cache]" __exc31_msg: .asciiz "" __level_msg: .asciiz "Interrupt mask: " ######################################################################### # Lookup table of exception messages __exc_msg_table: .word __exc0_msg, __exc1_msg, __exc2_msg, __exc3_msg, __exc4_msg .word __exc5_msg, __exc6_msg, __exc7_msg, __exc8_msg, __exc9_msg .word __exc10_msg, __exc11_msg, __exc12_msg, __exc13_msg, __exc14_msg .word __exc15_msg, __exc16_msg, __exc17_msg, __exc18_msg, __exc19_msg .word __exc20_msg, __exc21_msg, __exc22_msg, __exc23_msg, __exc24_msg .word __exc25_msg, __exc26_msg, __exc27_msg, __exc28_msg, __exc29_msg .word __exc30_msg, __exc31_msg # Variables for save/restore of registers used in the handler save_v0: .word 0 save_a0: .word 0 save_at: .word 0 ######################################################################### # This is the exception handler code that the processor runs when # an exception occurs. It only prints some information about the # exception, but can serve as a model of how to write a handler. # # Because this code is part of the kernel, it can use $k0 and $k1 without # saving and restoring their values. By convention, they are treated # as temporary registers for kernel use. # # On the MIPS-1 (R2000), the exception handler must be at 0x80000080 # This address is loaded into the program counter whenever an exception # occurs. For the MIPS32, the address is 0x80000180. # Select the appropriate one for the mode in which SPIM is compiled. .ktext 0x80000180 # Save ALL registers modified in this handler, except $k0 and $k1 # This includes $t* since the user code does not explicitly # call this handler. $sp cannot be trusted, so saving them to # the stack is not an option. This routine is not reentrant (can't # be called again while it is running), so we can save registers # to static variables. sw $v0, save_v0 sw $a0, save_a0 # $at is the temporary register reserved for the assembler. # It may be modified by pseudo-instructions in this handler. # Since an interrupt could have occurred during a pseudo # instruction in user code, $at must be restored to ensure # that that pseudo instruction completes correctly. .set noat sw $at, save_at .set at # Determine cause of the exception mfc0 $k0, $13 # Get cause register from coprocessor 0 srl $a0, $k0, 2 # Extract exception code field (bits 2-6) andi $a0, $a0, 0x1f # Check for program counter issues (exception 6) bne $a0, 6, ok_pc nop mfc0 $a0, $14 # EPC holds PC at moment exception occurred andi $a0, $a0, 0x3 # Is EPC word-aligned (multiple of 4)? beqz $a0, ok_pc nop # Bail out if PC is unaligned # Normally you don't want to do syscalls in an exception handler, # but this is MARS and not a real computer li $v0, 4 la $a0, __exc3_msg syscall li $v0, 10 syscall ok_pc: mfc0 $k0, $13 srl $a0, $k0, 2 # Extract exception code from $k0 again andi $a0, $a0, 0x1f bnez $a0, non_interrupt # Code 0 means exception was an interrupt nop # External interrupt handler # Don't skip instruction at EPC since it has not executed. # Interrupts occur BEFORE the instruction at PC executes. # Other exceptions occur during the execution of the instruction, # hence for those increment the return address to avoid # re-executing the instruction that caused the exception. # check if we are in here because of a character on the keyboard simulator # go to nochar if some other interrupt happened # get the character from memory # store it to a queue somewhere to be dealt with later by normal code andi $a0, $k0, 0x100 # check if keyboard interrupt beqz $a0, return # if not keyboard, return nop char: lui $a0, 0xffff # load keyboard char lw $v0, 4($a0) la $k0, char_queue # save char in queue la $k1, queue_end # load end lw $a0, 0($k1) add $k0, $k0, $a0 # save at end sb $v0, 0($k0) addi $a0, $a0, 1 # increment position andi $a0, $a0, 0xFF # wrap if >= 256 sw $a0, 0($k1) # update end j return nochar: # not a character # Print interrupt level # Normally you don't want to do syscalls in an exception handler, # but this is MARS and not a real computer li $v0, 4 # print_str la $a0, __level_msg syscall li $v0, 1 # print_int mfc0 $k0, $13 # Cause register srl $a0, $k0, 11 # Right-justify interrupt level bits syscall li $v0, 11 # print_char li $a0, 10 # Line feed syscall j return non_interrupt: # Print information about exception. # Normally you don't want to do syscalls in an exception handler, # but this is MARS and not a real computer li $v0, 4 # print_str la $a0, __start_msg_ syscall li $v0, 1 # print_int mfc0 $k0, $13 # Extract exception code again srl $a0, $k0, 2 andi $a0, $a0, 0x1f syscall # Print message corresponding to exception code # Exception code is already shifted 2 bits from the far right # of the cause register, so it conveniently extracts out as # a multiple of 4, which is perfect for an array of 4-byte # string addresses. # Normally you don't want to do syscalls in an exception handler, # but this is MARS and not a real computer li $v0, 4 # print_str mfc0 $k0, $13 # Extract exception code without shifting andi $a0, $k0, 0x7c lw $a0, __exc_msg_table($a0) nop syscall li $v0, 4 # print_str la $a0, __end_msg_ syscall # Return from (non-interrupt) exception. Skip offending instruction # at EPC to avoid infinite loop. mfc0 $k0, $14 addiu $k0, $k0, 4 mtc0 $k0, $14 return: # Restore registers and reset processor state lw $v0, save_v0 # Restore other registers lw $a0, save_a0 .set noat # Prevent assembler from modifying $at lw $at, save_at .set at mtc0 $zero, $13 # Clear Cause register # Re-enable interrupts, which were automatically disabled # when the exception occurred, using read-modify-write cycle. mfc0 $k0, $12 # Read status register andi $k0, 0xfffd # Clear exception level bit ori $k0, 0x0001 # Set interrupt enable bit mtc0 $k0, $12 # Write back # Return from exception on MIPS32: eret ######################################################################### # Standard startup code. Invoke the routine "main" with arguments: # main(argc, argv, envp) .text .globl __start __start: lw $a0, 0($sp) # argc = *$sp addiu $a1, $sp, 4 # argv = $sp + 4 addiu $a2, $sp, 8 # envp = $sp + 8 sll $v0, $a0, 2 # envp += size of argv array addu $a2, $a2, $v0 jal main nop li $v0, 10 # exit syscall .globl __eoth __eoth: