My Pastes
Public Pastes
Layout Width
Share Pastebin
Guest
Public paste!

Untitled

By: a guest | Mar 19th, 2010 | Syntax: None | Size: 7.40 KB | Hits: 80 | Expires: Never
Download | Raw | Embed | Report abuse
Copy text to clipboard
  1. ###################################################################
  2.  
  3. # CS232 MP 4
  4.  
  5. #
  6.  
  7. # To help you debug, I have added a "globl" label called exception.
  8.  
  9. # When you test your code, add exception as a breadkpoint, and your
  10.  
  11. # code will stop as soon as an exception is encountered. You can
  12.  
  13. # then step through the code until you finc the error.
  14.  
  15. ###################################################################
  16.  
  17.  
  18.  
  19. .data
  20.  
  21.   chunkIH : .space 16         # save space for four registers
  22.  
  23.   buffer  : .space 32768
  24.  
  25.   tokenxy : .space 1600       # space for 200 possible (x, y) values
  26.  
  27.   mystate : .word 0
  28.  
  29.   scandone: .word 0
  30.  
  31.  
  32.  
  33. .text
  34.  
  35. #### Start of main ####
  36.  
  37.  
  38.  
  39. main:
  40.  
  41.   # Step 0: Enable the necessary interrupts
  42.  
  43.   li    $t0, 0xb001    # enable bonk, scan and timer interrupts
  44.  
  45.   mtc0  $t0, $12       # set Status register
  46.  
  47.   #li $t7, 0
  48.  
  49.  
  50.  
  51.  
  52.   # Step 1: Start a new scan
  53.  
  54. main_start_scan:
  55.  
  56.   lw    $t0, 0xffff0020($0)  # get current x-coordinate
  57.  
  58.   sw    $t0, 0xffff0050($0)  # set as scan-x location
  59.  
  60.   lw    $t0, 0xffff0024($0)  # get current y-coordinate
  61.  
  62.   sw    $t0, 0xffff0054($0)  # set as scan-x location
  63.  
  64.   la    $t8, buffer          # get buffer address
  65.  
  66.   sw    $t8, 0xffff0058($0)  # start scan
  67.  
  68.  
  69.  
  70.   # Step 2: Wait for scan to terminate
  71. #bne $t7, $0, no_wait
  72.  
  73.   sw    $0, scandone
  74.   #addi $t7, $t7, 1
  75.  
  76. main_wait:
  77.  
  78.   lw    $t0, scandone
  79.  
  80.   beq   $t0, $0, main_wait
  81. no_wait:
  82.  
  83.  
  84.  
  85.   # Step 3: Compute pointer to root node (MP3b)
  86.  
  87.  
  88.   li    $t3, 0              # cumulative XOR
  89.   move $t4, $t8
  90.   addi $a1, $t4, 32768
  91.  
  92. main_loop:
  93.  
  94.  
  95.  
  96.   lw    $a0, 0($t4)         # get data
  97.  
  98.   jal   isEvenGraycode      # check if this node is even
  99.   lw    $t5, 4($t4)    
  100.  
  101.   xor   $t3, $t3, $t4      
  102.  
  103.   xor   $t3, $t3, $t5      
  104.  
  105. main_skip:
  106.  
  107.   addi  $t4, $t4, 8         # move on to next node
  108.   bne   $a1, $t4, main_loop
  109.  
  110.  
  111.  
  112. main_loop_done:             # v0 points to root node
  113.  
  114.   # Step 4: Drive to token location (hopefully!)
  115.   move $v0, $t3
  116.  
  117.   lw    $a0, 0($v0)         # a0 = root->data
  118.  
  119.   addi  $sp, $sp, -4
  120.  
  121.   sw    $ra, 0($sp)
  122.  
  123.   jal   getCoords
  124.  
  125.   lw    $ra, 0($sp)
  126.  
  127.   addi  $sp, $sp, 4
  128.  
  129.   la    $t6, tokenxy        # base address of tokenxy array
  130.  
  131.   sw    $v0, 0($t6)         # save x-coord
  132.  
  133.   sw    $v1, 4($t6)         # save y-coord
  134.  
  135.   sw    $0, mystate
  136.  
  137.   lw    $t0, 0xffff001c($0) # start timer
  138.  
  139.   addi  $t0, $t0, 100
  140.  
  141.   sw    $t0, 0xffff001c($0)
  142.  
  143.   j main_start_scan
  144.  
  145. main_state_0:
  146.  
  147.   lw    $t0, mystate
  148.  
  149.   beq   $t0, $0, main_state_0
  150.  
  151.   li    $t1, 1
  152.  
  153. main_state_1:
  154.  
  155.   lw    $t0, mystate
  156.  
  157.   beq   $t0, $t1, main_state_1
  158.  
  159.   j     main_start_scan     # now go for the next token
  160.  
  161.  
  162.  
  163.   jr    $ra                 # Should never get here!
  164.  
  165.  
  166.  
  167. #### End of main ####
  168.  
  169.  
  170.  
  171. #### Start of helper functions ####
  172.  
  173.  
  174.  
  175. isEvenGraycode:         # a0 = integer to check
  176.  
  177.   srl  $t1, $a0, 16     # shift right logical, not arithmetic!
  178.  
  179.   xor  $t0, $a0, $t1
  180.  
  181.   srl  $t1, $t0, 8
  182.  
  183.   xor  $t0, $t0, $t1
  184.  
  185.   srl  $t1, $t0, 4
  186.  
  187.   xor  $t0, $t0, $t1
  188.  
  189.   srl  $t1, $t0, 2
  190.  
  191.   xor  $t0, $t0, $t1
  192.  
  193.   srl  $t1, $t0, 1
  194.  
  195.   xor  $t0, $t0, $t1   # t0 = graycodeToBinary(a0)
  196.  
  197.   andi $v0, $t0, 1     # v0 = 1 iff t0 is odd
  198.   xori $v0, $v0, 1     # flip the bit
  199.   beq $v0, $0, main_skip
  200.  
  201.   jr    $ra
  202.  
  203.  
  204.  
  205. getCoords:             # a0 = integer data
  206.  
  207.   srl  $t1, $a0, 16    # shift right logical, not arithmetic!
  208.  
  209.   xor  $t0, $a0, $t1
  210.  
  211.   srl  $t1, $t0, 8
  212.  
  213.   xor  $t0, $t0, $t1
  214.  
  215.   srl  $t1, $t0, 4
  216.  
  217.   xor  $t0, $t0, $t1
  218.  
  219.   srl  $t1, $t0, 2
  220.  
  221.   xor  $t0, $t0, $t1
  222.  
  223.   srl  $t1, $t0, 1
  224.  
  225.   xor  $t0, $t0, $t1   # t0 = graycodeToBinary(a0)
  226.  
  227.   sra  $t0, $t0, 1     # t0 = 256x + y
  228.  
  229.   andi $v1, $t0, 0xFF  # v1 = t0 mod 256 = y
  230.  
  231.   srl  $v0, $t0, 8     # v0 = t0 / 256   = x
  232.  
  233.   jr    $ra
  234.  
  235.  
  236.  
  237. #### End of helper functions ####
  238.  
  239.  
  240.  
  241. #### Kernel section ####
  242.  
  243.  
  244.  
  245. .ktext 0x80000080
  246.  
  247. interrupt_handler:
  248.  
  249.   .set noat
  250.  
  251.   move  $k1, $at            # save $at
  252.  
  253.   .set at
  254.  
  255.   la    $k0, chunkIH
  256.  
  257.   sw    $t0, 0($k0)         # save registers
  258.  
  259.   sw    $t1, 4($k0)
  260.  
  261.   sw    $a0, 8($k0)
  262.  
  263.   sw    $a1, 12($k0)
  264.  
  265.  
  266.  
  267.   mfc0  $t0, $13            # get Cause register
  268.  
  269.   srl   $t1, $t0, 2
  270.  
  271.   andi  $t1, $t1, 0xF       # examine exception code field
  272.  
  273.   bne   $t1, 0, exception   # if its non-zero, it is an exception
  274.  
  275.  
  276.  
  277.   # Now examine the kind of interrupt we have
  278.  
  279.   andi  $t1, $t0, 0x1000    # is this a bonk interrupt?
  280.  
  281.   bne   $t1, $0, bonk_interrupt
  282.  
  283.  
  284.  
  285.   andi  $t1, $t0, 0x2000    # is this a scan interrupt?
  286.  
  287.   bne   $t1, $0, scan_interrupt
  288.  
  289.  
  290.  
  291.   andi  $t1, $t0, 0x8000    # is this a timer interrupt?
  292.  
  293.   bne   $t1, $0, timer_interrupt
  294.  
  295.  
  296.  
  297.   j     int_done            # unknown interrupt
  298.  
  299.  
  300.  
  301. bonk_interrupt:
  302.  
  303.   sw    $0, 0xffff0060($0)  # acknowledge bonk interrupt
  304.  
  305.   # We should not get a bonk. If we do, we must be chasing a bad token
  306.  
  307.   li    $t0, 2
  308.  
  309.   sw    $t0, mystate        # ignore this "token"!
  310.  
  311.  
  312.  
  313.   j     int_done
  314.  
  315.  
  316.  
  317. scan_interrupt:
  318.  
  319.   sw    $0, 0xffff0064($0)  # acknowledge scan interrupt
  320.  
  321.   li    $t0, 1              # set scandone = 1 to quit main_wait loop
  322.  
  323.   sw    $t0, scandone
  324.  
  325.   j     int_done
  326.  
  327.  
  328.  
  329. timer_interrupt:
  330.  
  331.   sw    $0, 0xffff006c($0)  # acknowledge timer interrupt
  332.  
  333.   la    $a0, tokenxy
  334.   #move $a0, $s0
  335.  
  336.  
  337.   #beq $a0, $t6, int_done  
  338.   lw    $t0, mystate
  339.  
  340.   bne   $t0, $0, move_along_y
  341.  
  342.   lw    $a0, 0($a0)
  343.  
  344.   lw    $t0, 0xffff0020($0)  # t0 = spimbot_get_x()
  345.  
  346.   sub   $t0, $a0, $t0        # t0 = diff
  347.  
  348.   abs   $t1, $t0             # t1 = abs(diff)
  349.  
  350.   bge   $t1, 2, x_else
  351.  
  352.   li    $t0, 1
  353.  
  354.   sw    $t0, mystate
  355.  
  356.   j     move_along_y
  357.  
  358. x_else:
  359.  
  360.   ble   $t0, $0, x_180
  361.  
  362.   sw    $0, 0xffff0014($0)
  363.  
  364.   li    $t0, 1
  365.  
  366.   sw    $t0, 0xffff0018($0)
  367.  
  368.   j     x_set_timer
  369.  
  370. x_180:
  371.  
  372.   li    $t0, 180
  373.  
  374.   sw    $t0, 0xffff0014($0)
  375.  
  376.   li    $t0, 1
  377.  
  378.   sw    $t0, 0xffff0018($0)
  379.  
  380. x_set_timer:
  381.  
  382.   li    $t0, 10
  383.  
  384.   mul   $t1, $t1, 10
  385.  
  386.   lw    $t0, 0xffff001c($0)
  387.  
  388.   add   $t0, $t0, $t1
  389.  
  390.   sw    $t0, 0xffff001c($0)
  391.  
  392.   li    $t0, 10
  393.  
  394.   sw    $t0, 0xffff0010($0)
  395.  
  396.  
  397.  
  398. move_along_y:
  399.  
  400.   lw    $t0, mystate
  401.  
  402.   bne   $t0, 1, int_done
  403.  
  404.  
  405.  
  406.   la    $a1, tokenxy
  407.   #move $a1, $s0
  408.  
  409.   lw    $a1, 4($a1)
  410.  
  411.   lw    $t0, 0xffff0024($0)  # t0 = spimbot_get_y()
  412.  
  413.   sub   $t0, $a1, $t0        # t0 = diff
  414.  
  415.   abs   $t1, $t0             # t1 = abs(diff)
  416.  
  417.   bge   $t1, 2, y_else
  418.  
  419.   li    $t0, 2
  420.  
  421.   sw    $t0, mystate
  422.  
  423.   sw    $0, 0xffff0010($0)   # stop driving!
  424.   #addi $s0, $s0, 8
  425.  
  426.   j     int_done
  427.  
  428. y_else:
  429.  
  430.   ble   $t0, $0, y_270
  431.  
  432.   li    $t0, 90
  433.  
  434.   sw    $t0, 0xffff0014($0)
  435.  
  436.   li    $t0, 1
  437.  
  438.   sw    $t0, 0xffff0018($0)
  439.  
  440.   j     y_set_timer
  441.  
  442. y_270:
  443.  
  444.   li    $t0, 270
  445.  
  446.   sw    $t0, 0xffff0014($0)
  447.  
  448.   li    $t0, 1
  449.  
  450.   sw    $t0, 0xffff0018($0)
  451.  
  452. y_set_timer:
  453.  
  454.   li    $t0, 10
  455.  
  456.   mul   $t1, $t1, 100
  457.  
  458.   lw    $t0, 0xffff001c($0)
  459.  
  460.   add   $t0, $t0, $t1
  461.  
  462.   sw    $t0, 0xffff001c($0)
  463.  
  464.   li    $t0, 10
  465.  
  466.   sw    $t0, 0xffff0010($0)
  467.  
  468.  
  469.  
  470. int_done:
  471.  
  472.   la    $k0, chunkIH
  473.  
  474.   lw    $t0, 0($k0)         # restore registers
  475.  
  476.   lw    $t1, 4($k0)
  477.  
  478.   lw    $a0, 8($k0)
  479.  
  480.   lw    $a1, 12($k0)
  481.  
  482.   .set noat
  483.  
  484.   move  $at, $k1            # restore $at
  485.  
  486.   .set at
  487.  
  488.  
  489.  
  490.   mfc0  $k0, $14            # EPC
  491.  
  492.   rfe                       # return from exception handler
  493.  
  494.   jr    $k0
  495.  
  496.  
  497.  
  498. #### Global exception label ####
  499.  
  500. .globl exception
  501.  
  502. exception:
  503.  
  504.   j     int_done
  505.  
  506.  
  507.  
  508. #### End of program ####
create new paste | create new version of this paste RAW Paste Data