A moving assembly line for vehicles conveys two different types of cars: blue La

Question

A moving assembly line for vehicles conveys two different types of cars: blue Lada (B) and yellow Corvettes (Y). They go down the line sequenced B-B-Y-B-B-Y-B-B and so on but need to be sorted for shipping. Notice that before a yellow car, there is a separation of 2 minutes. Just before the sorter, there is a vision sensor (V) that detects the type of car that is coming down the line. This sensor fires exactly every 60 seconds, which is the time needed for the next vehicle to reach that inspection point. However, the sensor needs to wait for 2 minutes every time a yellow vehicle is approaching, otherwise, a false (no car) reading will shut down the system. Once the sensor detects the type of vehicle, the motor (M) will route the cars to the appropriate conveyor. Develop a PLC ladder logic diagram that performs this behavior. You may use additional inputs/outputs beyond what is given in the problem but please explain what they are. Clearly state any assumptions you may need to make.

Explanation / Answer

.text
main:
j mm

mm:
la $a3, array_A # base address for array_A loaded into $a3
la $a1, array_B # base address for array_B loaded into $a1
la $a2, array_C # base address for array_C loaded into $a2

li $t1, four # $t1 = four (row-size and loop end)
li $s0, zero # i = 0; initialize first for loop
loop1:
li $s1, zero # j = 0; restart 2d for loop
loop2:
li $s2, zero # k = 0; restart third for loop
sll $t2, $s0, two # $t2 = i * four (size of row of c)
addu $t2, $t2, $s1 # $t2 = i * size(row) + j
sll $t2, $t2, two # $t2 = computer memory unit offset of [i][j]
addu $t2, $a2, $t2 # $t2 = computer memory unit offset of [i][j]
lw $t4, 0($t2) # $t4 = two bytes of c[i][j]
loop3:
sll $t0, $s2, two # $t0 = k * four (size of row of b)
addu $t0, $t0, $s1 # $t0 = k * size(row) + j
sll $t0, $t0, two # $t0 = computer memory unit offset off [k][j]
addu $t0, $a1, $t0 # $t0 = computer memory unit address of b[k][j]
lw $t5, 0($t0) # $t5 = two bytes of b[k][j]
sll $t0, $s0, two # $t0 = i * four (size of row of a)
addu $t0, $t0, $s2 # $t0 = i * size(row) + k
sll $t0, $t0, two # $t0 = computer memory unit offset of [i][k]
addu $t0, $a3, $t0 # $t0 = computer memory unit address of a[i][k]
lw $t6, 0($t0) # $t6 = two bytes of a[i][k]
mul $t5, $t6, $t5 # $t5 = a[i][k] * b[k][j]
add $t4, $t4, $t5 # $t4 = c[i][j] + a[i][k] * b[k][j]
addiu $s2, $s2, one # $k = k + one
bne $s2, $t1, loop3 #if (k != 4) attend loop3
sw $t4, 0($a2) # c[i][j] = $t4
#----------TEST-------------
li $v0, 1
lw $a0, ($a2)
syscall
li $v0, 4
la $a0, new_row
syscall
#----------TEST-------------

addiu $s1, $s1, one # $j = j + one
addi $a2, $a2, 4
bne $s1, $t1, loop2 # if (j != 4) attend loop2

addiu $s0, $s0, one # $i = i + one
bne $s0, $t1, loop1 # if (i != 32) attend L1

Exit:
li $v0, 10 #exits
syscall

.data
array_A: .word 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
array_B: .word 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
array_C: .word 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
output_row_string_C: .asciiz "Matrix C Output Row "
colon_string: .asciiz ":
space_string: .asciiz " "
new_row: .asciiz " "
char_space: .space 2

Related Questions

Navigate

• Browse (All)
• Browse A
• Subjects

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