1. Write a MIPS assembly language program that asks the user for 10 integers one

Question

1. Write a MIPS assembly language program that asks the user for 10 integers one at a time and stores them in memory.

(a). Each integer must be in the range 0 to 15 inclusive.

2. Converts each integer into the Hammering code according to the following rules.

(a). Convert the integer to a binary integer of length 4.

i. 3 -> 0011

ii. 8 -> 1000

iii. 12 -> 1100

(b). Assign values to d1 to d4.

i. 0110 -> d1 = 0, d2 = 1, d3 = 1, d4 = 0

ii. 1000 -> d1 = 1, d2 = 0, d3 = 0, d4 = 0

iii. 1100 -> d1 = 0, d2 = 1, d3 = 0, d4 = 0

(c). Compute p1 to p3.

i. (p1 + d1 + d2 + d4) % 2 = 0

ii. (p2 + d1 + d3 + d4) % 2 = 0

iii. (p3 + d2 + d3 + d4) % 2 = 0

(d). Build a binary number.

i. p1p2d1p3d2d3d4

(e). Convert this binary number back into a integer.

3. Prints the 10 Hammering code integers separated by a space.

Explanation / Answer

MIPS to enter 10 integers and hamming code generation

ScreenShot

---------------------------------------------------------------------------------------------------------

Code

#variable declaration
.data
      Integer: .asciiz "Please enter 10 integer values between 0-15:"
      IntArray: .space 10
      array: .space 10
    
.text
      la $t0,IntArray       #load array address
      li $t1,10             #counter to enter 10 elements
      move $a1,$10          #move counter to a1
     #prompt user to enter values
      li $v0,4
      la $a0,Integer
      syscall
#loop to enter 10 integers
Loop:
      beqz $t1,next   #counter to enter 10 elements
      #read integer
      li $v0,5
      syscall
      #check less tha 0
      blt $v0,0,goto
      #check greater than 15
      bgt $v0,15,goto
      #store into array
      sb $v0,0($t0)
      #increment memory
      addi $t0,$t0,4
      #decrement counter
      addi $t1,$t1,-1
goto:
      j Loop
#after enter 10 elements
next:
       la $a0,IntArray
       jal ham
       li $v0,10
       syscall
#Hamming generation
ham:
li $a1,10
move $s0,$a0
loop:
beqz $a1,exit
lb $t0,0($s0)
div $t0,$t0,2
mfhi $t1     #d4
div $t0,$t0,2
mfhi $t2    #d3
div $t0,$t0,2
mfhi $t3   #d2
div $t0,$t0,2
mfhi $t4   #d1
#parity check p1
add $s2,$t4,$t3
add $s2,$s2,$t1
#parity assumption
li $t5,1
add $s2,$s2,$t5
div $s2,$s2,2
mfhi $s2
bnez $s2,setpar
#parity check p2
li $s2,0
add $s2,$t4,$t2
add $s2,$s2,$t1
   #parity assumption
li $t6,1
add $s2,$s2,$t6
div $s2,$s2,2
mfhi $s2
bnez $s2,setpar1
#parity check p3
li $s2,0
add $s2,$t3,$t2
add $s2,$s2,$t1
   #parity assumption
li $t7,1
add $s2,$s2,$t7
div $s2,$s2,2
mfhi $s2
bnez $s2,setpar2
#generate hamming code
la $s3,array
sb $t1,0($s3)
sb $t2,1($s3)
sb $t3,2($s3)
sb $t7,3($s3)
sb $t4,4($s3)
sb $t6,5($s3)
sb $t5,6($s3)

startConvert:
la $t1, array
li $t9, 6             # initialize counter to 16

firstByte:
lb $a0, ($t1)      # load the first byte
blt $a0, 48, printSum    # I don't think this line works
addi $t1, $t1, 1          # increment offset
subi $a0, $a0, 48         # subtract 48 to convert to int value
subi $t9, $t9, 1          # decrement counter
beq $a0, 0, isZero
beq $a0, 1, isOne
j convert     #

isZero:
   j firstByte

isOne:                   # do 2^counter
   li $t8, 1               # load 1
   sllv $t5, $t8, $t9    # shift left by counter = 1 * 2^counter, store in $t5
   add $t4, $t4, $t5         # add sum to previous sum

   move $a0, $t4        # load sum
   li $v0, 1              # print int
   syscall
   j firstByte

convert:

printSum:
   srlv $t4, $t4, $t9
   move $a0, $t4      # load sum
   li $v0, 1      # print int
   syscall
   addi $s0,$s0,1
   addi $a1,$a1,-1
   j loop
exit:
   jr $ra
setpar:
   li $t5,0
setpar1:
   li $t6,0
setpar2:
   li $t7,0
   #generate hamming code
la $s3,array
sb $t1,0($s3)
sb $t2,1($s3)
sb $t3,2($s3)
sb $t7,3($s3)
sb $t4,4($s3)
sb $t6,5($s3)
sb $t5,6($s3)

startConvert1:
la $t1, array
li $t9, 6             # initialize counter to 16

firstByte1:
lb $a0, ($t1)      # load the first byte
blt $a0, 48, printSum1    # I don't think this line works
addi $t1, $t1, 1          # increment offset
subi $a0, $a0, 48         # subtract 48 to convert to int value
subi $t9, $t9, 1          # decrement counter
beq $a0, 0, isZero1
beq $a0, 1, isOne1
j convert1     #

isZero1:
   j firstByte

isOne1:                   # do 2^counter
   li $t8, 1               # load 1
   sllv $t5, $t8, $t9    # shift left by counter = 1 * 2^counter, store in $t5
   add $t4, $t4, $t5         # add sum to previous sum

   move $a0, $t4        # load sum
   li $v0, 1              # print int
   syscall
   j firstByte1

convert1:

printSum1:
   srlv $t4, $t4, $t9
   move $a0, $t4      # load sum
   li $v0, 1      # print int
   syscall
   addi $s0,$s0,1
   addi $a1,$a1,-1
   j loop
   jr $ra

Related Questions

Navigate

• Browse (All)
• Browse 1
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.