Why isn't is reading the UART?

# you may add initializations after line $10,$ but please do not

# remove or change the initializations to $sp$,$ $s$0,$ $s$1,$ or $s$2$

li $sp$,0$x$10$fffffc # Starting address of empty stack

li $s$0,0$xf$0000000$ # UART base address

li $s$1,$ array$\_$ptr # Array head pointer

li $s$2,$ array$\_$ptr # Array tail pointer

#

# Do not make changes to the jump to main, the allocation of

# memory for the array, or the main loop

#

j main

nop

array$\_$ptr: # Label pointing to $100$ word array

$.$space $100$

main:

jal poll$\_$UART

nop

jal period$\_$check

nop

jal space$\_$check

nop

jal case$\_$check

nop

jal array$\_$push

nop

j main

nop

# The "poll$\_$UART" function should poll the status register of the UART.

# If the $2^1$ bit position $($ready bit$)$ is set to $1$ then it

# should copy the receive buffer's value into $v$0$ and send

# a clear status command $(2^1)$ to the command register before

# returning $($a return statement is already included$).$ In order to

# receive full credit, $s$0$ must contain the base address of the UART

# and must be used with the appropriate offsets to access UART

# registers and buffers

poll$\_$UART:

lw $t$0,0($$s$0)$ # Load UART status register

andi $t$0,$ $t$0,0$x$01$ # Mask to get the ready bit

beq $t$0,$ $zero, poll$\_$UART # If not ready, return

lw $v$0,4($$s$0)$ # Load the received character

sw $zero, $0($$s$0)$ # Clear the status register

jr $ra

nop

# The "period$\_$check" function should check if the current character $($$v$0)$

# is a period $(".").$ If it is a period then the function should go to the

# label, "palindrome$\_$check". If the character is not a period then it

# should use the included return.

period$\_$check:

li $t$0,46$ # $46$ is the ASCII value of $\text{'}.\text{'}$

beq $v$0,$ $t$0,$ palindrome$\_$check

jr $ra

nop

# The "space$\_$check" function should check if the current character $($$v$0)$

# is a space $("").$ If it is then it should jump to "main" so

# that it skips saving the space character. If not it should

# use the included return.

space$\_$check:

li $t$0,32$ # $32$ is the ASCII value of $\text{'}\text{'}$

beq $v$0,$ $t$0,$ main # return to main if space

jr $ra

nop

# The "case$\_$check" function should perform a single inequality check.

# If the current character $($$v$0)$ is greater than the ASCII value of $\text{'}$Z$\text{'},$

# which indicates the current character is lowercase, then it should convert

# the value of $v$0$ to the uppercase equivalent and then return. If the

# current character $($$v$0)$ is already uppercase $($meaning the inequality

# mentioned before was not true$)$ then the function should return without

# performing a conversion.

case$\_$check:

li $t$1,90$

li $t$2,1$

slt $t$3,$ $v$0,$ $t$1$ # checks if uppercase

beq $v$0,$ $t$2,$ return # jumps if uppercase

addiu $v$0,$ $v$0,-32$ # changes lowercase to uppercase

return:

jr $ra

nop

# The "array$\_$push" function should save the current character $($$v$0)$ to the

# current location of the tail pointer, $s$2.$ Then it should increment the

# tail pointer so that it points to the next element of the array. Last

# it should use the included return statement.

array$\_$push:

sw $v$0,0($$s$2)$

addiu $s$2,$ $s$2,4$

jr $ra

nop

# The "palindrome$\_$check" subroutine should be jumped to by the period

# check function if a period is encountered. This subroutine should contain

# a loop that traverses the array from the front towards the back $($using the

# head pointer, $s$1)$ and from the back towards the front$($using the tail

# pointer, $s$2).$ If the string is a palindrome then as the array is traversed

# the characters pointed to should be equal. If the characters are not equal

# then the string is not a palindrome and the print function should be used

# to print $"$No$".$ If the pointers cross $($i$.$e$.$ the head pointer's address is

# greater than or equal to the tail pointer's address$)$ and the compared

# characters are equal then the string is a palindrome and "Yes" should be

# printed.

#

# Remember to restore the head and tail pointers to the first element

# of the array before the subroutine jumps back to main to begin processing the

# next string. Also, keep in mind that because the tail pointer is updated at

# the end of "array$\_$push" it technically points one element past the last

# character in the array. You will need to compensate for this by either

# decrementing the pointer once at the start of the array or using an offset

# from this pointer's address.

palindrome$\_$check:

addiu $s$2,$ $s$2,-4$ # point tail pointer to last char

loop:

lw $t$0,0($$s$1)$ # load char from head

lw $t$1,0($$s$2)$ # load char from tail

bne $t$0,$ $t$1,$ not$\_$palindrome

addiu $s$1,$ $s$1,4$ # increment head pointer

addiu $s$2,$ $s$2,-4$ # decrement tail pointer

beq $s$1,$ $s$2,$ loop

is$\_$palindrome:

li $a$0,1$

call project$3\_$print # display "Yes"

j reset$\_$pointers

nop

not$\_$palindrome:

li $a$0,0$

call project$3\_$print # display $"$No$"$

j reset$\_$pointers

nop

reset$\_$pointers:

li $s$1,$ array$\_$ptr # restores head pointer

li $s$2,$ array$\_$ptr # restores tail pointer

jr $ra

nop