SHARE
TWEET

Untitled

a guest May 23rd, 2019 65 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. ;
  2. ; Snake.asm
  3. ;
  4. ; Created: 2019-04-26 13:46:35
  5. ; Author : jesper.li
  6. ;
  7.  
  8.  
  9. ; Replace with your application code
  10. .DEF rTemp         = r20
  11. .DEF rDirection    = r21
  12.  
  13. .DEF rD = r23
  14. .DEF rB = r24
  15. .DEF rC = r25
  16. .DEF i0 = r0 //immidiate 0
  17. .DEF i1 = r1 //immidiate 1
  18. .DEF i2 = r2 //immidiate 2
  19. .DEF i4 = r3 //immidiate 4
  20. .DEF i8 = r4 //immidiate 8
  21. .DEF i16 = r5 //immidiate 16
  22. .DEF i32 = r6 //immidiate 32
  23.  
  24. .DEF input = r13
  25.  
  26.  
  27. .DEF length = r10
  28. .DEF snakePos = r15
  29. .DEF snakeBodyPos = r14
  30.  
  31. .DEF rRow = r22
  32.  
  33. .DSEG
  34.     matrix:   .BYTE 8
  35.        
  36.     bodyDirection: .BYTE 16
  37.  
  38.     interupt: .BYTE 1
  39.  
  40. .CSEG
  41. // Interrupt vector table
  42. .ORG 0x0000
  43.      jmp init // Reset vector
  44.  
  45. .ORG 0x0020
  46. jmp isr_timerOF // Timer 0 overflow vector
  47.      
  48. //... fler interrupts
  49. .ORG INT_VECTORS_SIZE
  50.  
  51.     //interrupt handler for timer
  52. isr_timerOF:
  53.     push r18
  54.     ldi r18, 1
  55.     st X, r18
  56.     pop r18
  57.     reti
  58.      
  59.  
  60. init:
  61.      ldi ZH, HIGH(bodyDirection)
  62.      ldi ZL, LOW(bodyDirection)
  63.  
  64.    
  65.      // Sätt stackpekaren till högsta minnesadressen
  66.      ldi rTemp, HIGH(RAMEND)
  67.      out SPH, rTemp
  68.      ldi rTemp, LOW(RAMEND)
  69.      out SPL, rTemp
  70.      
  71.      ldi XH, HIGH(interupt)
  72.      ldi XL, LOW(interupt)
  73.  
  74.      ldi r16, 0b11001111
  75.      out DDRC, r16
  76.  
  77.      ldi r16, 0b11111111
  78.      out DDRD, r16
  79.  
  80.      ldi r16, 0b11111111
  81.      out DDRB, r16
  82.    
  83.  
  84.      //sätter värdet på olika icke-immediate register så att vi kan lättare få tillgång till användbara siffror
  85.      sub r0, r0
  86.      ldi r18, 1
  87.      mov r1, r18
  88.      ldi r18, 2
  89.      mov r2, r18
  90.      ldi r18, 4
  91.      mov r3, r18
  92.      ldi r18, 8
  93.      mov r4, r18
  94.     ldi r18, 16
  95.     mov r5, r18
  96.     ldi r18, 32
  97.     mov r6, r18
  98.        
  99.     mov r10, r0
  100.  
  101.     ldi r18, 0b00000000
  102.     mov snakePos, r18
  103.  
  104.    
  105.     //Global Interrupt Enable
  106.     sei
  107.  
  108.     //Enable Timer Interrupt
  109.     ldi r18, 0b00000001
  110.     sts TIMSK0, r18
  111.  
  112.     //  A/D Omvandlare
  113.      ldi r16, (1<<REFS0) + (0<<REFS1) + (1<<ADLAR)
  114.      sts ADMUX, r16
  115.  
  116.      ldi r16, 0b10000111
  117.      sts ADCSRA, r16
  118.  
  119.     mov r17, i0
  120.      //
  121.        // Första fyra bitarna representerar analog input 4 (y axeln)
  122.     ldi r16, 0b01000010
  123.     sts ADMUX, r16
  124.  
  125.     //Sätter bit 6 till 1. För att starta omvandling
  126.     ldi r16, 0b11100011
  127.     sts ADCSRA, r16
  128.  
  129.     mov r7, i0
  130.     ldi YH, HIGH(matrix)
  131.     ldi YL, LOW(matrix)
  132.  
  133.     ldi r18, 0b00000000
  134.     st Y+, r18
  135.     //adiw Y, 1
  136.     ldi r18, 0b00000000
  137.     st Y+, r18
  138.     //adiw Y, 1
  139.     ldi r18, 0b00000000
  140.     st Y+, r18
  141.     //adiw Y, 1
  142.     ldi r18, 0b00000000
  143.     st Y+, r18
  144.     //adiw Y, 1
  145.     ldi r18, 0b00000000
  146.     st Y+, r18
  147.     //adiw Y, 1
  148.     ldi r18, 0b00000000
  149.     st Y+, r18
  150.     //adiw Y, 1
  151.     ldi r18, 0b00000000
  152.     st Y+, r18
  153.     //adiw Y, 1
  154.     ldi r18, 0b00000000
  155.     st Y, r18
  156.  
  157. start:
  158.     ldi YH, HIGH(matrix)
  159.     ldi YL, LOW(matrix)
  160.     ldi r19, 0
  161.     //ser till att vi loopar alla rader 32 gånger innan den kör spel logiken igen
  162.     add r7, i1
  163.     cp r7, i32
  164.     breq nojump1
  165.  
  166.     rjmp loop
  167.  
  168.  
  169.  
  170. nojump1:
  171.  
  172.     mov r7, i0 
  173.         //Laddar in matrisen "matrix" i Y
  174.  
  175.     //st Y, i0
  176.  
  177.     //Skriv spel logik här  vvvvv
  178.  
  179.     lds r16, ADMUX
  180.     ori r16, 5    ; Choose y axel
  181.     sts ADMUX, r16
  182.     lds r18, ADCSRA
  183.     andi r18, 0b01000000
  184.     sts ADCSRA, r18
  185.     rcall ADSCWait        ;Wait until ADSC is zero
  186.     lds        input, ADCL
  187.     lds        input, ADCH
  188.  
  189.        
  190.     //st Y, input
  191.  
  192.     //tar fram X värdet från snakePos och pushar den till bitarna längst till höger
  193.     ldi r16, 0b11110000
  194.     and r16, snakePos
  195.     LSR r16
  196.     LSR r16
  197.     LSR r16
  198.     LSR r16
  199.  
  200.     //tar fram Y värdeet från snakePos
  201.     ldi r17, 0b00001111
  202.     and r17, snakePos
  203.  
  204.  
  205.  
  206.  
  207.     //itererar ner till rätt rad i Y värdet
  208. miniy:
  209.     cp r17, i0
  210.     breq miniyend
  211.     sub r17, i1
  212.     adiw Y, 1
  213.  
  214.     jmp miniy
  215.  
  216. miniyend:
  217.  
  218.  
  219.     //itererar till rätt X värde i kolumnen
  220.     ldi r18, 0b10000000
  221. minix:
  222.     cp r16, i0
  223.     breq minixend
  224.     sub r16, i1
  225.     LSR r18
  226.     jmp minix
  227.  
  228. minixend:
  229.     ld r17, Y
  230.     or r18, r17
  231.     //ldi r18, 0b11111111
  232.     st Y, r18
  233.  
  234.     ldi YH, HIGH(matrix)
  235.     ldi YL, LOW(matrix)
  236.  
  237.  
  238.     mov snakeBodyPos, snakePos
  239.  
  240.     ldi r18, 0b00000011
  241.     mov r9, r18
  242.     cpi r18, 3
  243.     breq snakeDown
  244.  
  245.     jmp snakeEnd
  246. snakeDown:
  247.     add snakePos, i1
  248.  
  249.     ld r18, Z
  250.     LSR r18
  251.     LSR r18
  252.  
  253.  
  254.     //spara inversen
  255.     bst i0, 0
  256.     bld r18, 7
  257.     bld r18, 6
  258.  
  259.     //sparar in nya värdet i Z igen
  260.     st Z, r18
  261.  
  262.  
  263.     mov r12, i1
  264.     ld r18, Z
  265. snakeEnd:
  266.     cp r12, i4
  267.     breq beforeLoop
  268.  
  269.  
  270.  
  271.     bst r18, 7
  272.     bld r16, 1
  273.     bst r18, 6
  274.     bld r16, 0
  275.  
  276.     //and r16, r18
  277.     //tar fram X värdet från snakePos och pushar den till bitarna längst till höger
  278.     ldi r16, 0b11110000
  279.     and r16, snakeBodyPos
  280.     LSR r16
  281.     LSR r16
  282.     LSR r16
  283.     LSR r16
  284.  
  285.     //tar fram Y värdeet från snakePos
  286.     ldi r17, 0b00001111
  287.     and r17, snakePos
  288.  
  289.  
  290.  
  291.  
  292.     //itererar ner till rätt rad i Y värdet
  293. miniy1:
  294.     cp r17, i0
  295.     breq miniyend1
  296.     sub r17, i1
  297.     adiw Y, 1
  298.  
  299.     jmp miniy1
  300.  
  301. miniyend1:
  302.  
  303.  
  304.     //itererar till rätt X värde i kolumnen
  305.     ldi r18, 0b01111111
  306. minix1:
  307.     cp r16, i0
  308.     breq minixend1
  309.     sub r16, i1
  310.     ROR r18
  311.     jmp minix1
  312.  
  313. minixend1:
  314.     ld r17, Y
  315.     and r18, r17
  316.     st Y, r18
  317.  
  318.     ldi YH, HIGH(matrix)
  319.     ldi YL, LOW(matrix)
  320.  
  321.  
  322. indexUp:
  323.     cpi r16, 0
  324.     brne indexDown
  325.        
  326.     sub snakeBodyPos, i1
  327.  
  328.     rjmp indexMoveEnd
  329. indexDown:
  330.     cpi r16, 3
  331.     brne indexLeft
  332.  
  333.     add snakeBodyPos, i1
  334.  
  335.     rjmp indexMoveEnd
  336. indexLeft:
  337.     cpi r16, 2
  338.     brne indexRight
  339.  
  340.     sub snakeBodyPos, i16
  341.  
  342.     rjmp indexMoveEnd
  343. indexRight:
  344.  
  345.     add snakeBodyPos, i16
  346. indexMoveEnd:
  347.  
  348.     add r12, i1
  349.     LSL r18
  350.     LSL r18
  351.     jmp snakeEnd
  352.  
  353.  
  354.  
  355.     //                      ^^^^^
  356. beforeLoop:
  357.  
  358.    
  359.  
  360. loop:
  361.     //Skriver r18 till en plats i Y
  362.     //Detta stycket borde också finnas med i spel logiken senare
  363.     ldi r20, 0b00000011
  364.     out TCCR0B, r20
  365.     ld rRow, Y
  366.     mov rD, rRow
  367.  
  368.  
  369.    
  370.    
  371.     add r11, i1
  372.     cp r11, i8
  373.     brne dontset0
  374.  
  375.     mov r11, i0
  376.    
  377.  
  378. dontset0:
  379.     //Byter plats på bits. 7 är vänster, 0 är höger
  380.     bst rRow, 7
  381.     bld rD, 6
  382.     bst rRow, 6
  383.     bld rD, 7
  384.  
  385.     bst rRow, 5
  386.     bld rD, 0
  387.     bst rRow, 0
  388.     bld rD, 5
  389.  
  390.     bst rRow, 4
  391.     bld rD, 1
  392.     bst rRow, 1
  393.     bld rD, 4
  394.  
  395.     bst rRow, 3
  396.     bld rD, 2
  397.     bst rRow, 2
  398.     bld rD, 3
  399.  
  400.  
  401.     //Kopierar rD till rB
  402.     mov rB, rD
  403.  
  404.     //sparar de relevanta bitsen i rD till portD
  405.     andi rD, 0b11000000
  406.    
  407.     //sparar de relevanta bitsen i rB till portB
  408.     andi rB, 0b00111111
  409.    
  410.  
  411.  
  412. //Start av indexering
  413. //Switch case funktion gör olika saker beroende på vilken rad
  414. index0:
  415.     cpi r19, 0
  416.     brne index1
  417.        
  418.     ldi rC, 0b00000001
  419.  
  420.     rjmp indexEnd
  421. index1:
  422.     cpi r19, 1
  423.     brne index2
  424.  
  425.     ldi rC, 0b00000010
  426.  
  427.     rjmp indexEnd
  428. index2:
  429.     cpi r19, 2
  430.     brne index3
  431.  
  432.     ldi rC, 0b00000100
  433.  
  434.     rjmp indexEnd
  435. index3:
  436.     cpi r19, 3
  437.     brne index4
  438.  
  439.     ldi rC, 0b00001000
  440.  
  441.     rjmp indexEnd
  442. index4:
  443.     cpi r19, 4
  444.     brne index5
  445.  
  446.     ori rD, 0b00000100
  447.  
  448.     rjmp indexEnd
  449. index5:
  450.     cpi r19, 5
  451.     brne index6
  452.  
  453.     ori rD, 0b00001000
  454.  
  455.     rjmp indexEnd
  456. index6:
  457.     cpi r19, 6
  458.     brne index7
  459.  
  460.     ori rD, 0b00010000
  461.  
  462.     rjmp indexEnd
  463. index7:
  464.     cpi r19, 7
  465.     brne indexEnd
  466.  
  467.     ori rD, 0b00100000
  468.  
  469. indexEnd:
  470.    
  471.     //Tänder lampor
  472.     out PORTD, rD
  473.     out PORTB, rB
  474.     out PORTC, rC
  475.  
  476. noppp:
  477.     ld r8, X
  478.     cp r8, i0
  479.     breq noppp
  480.     st X, i0
  481.  
  482.     //rensar alla lampor
  483.     ldi r18, 0b00000000
  484.     mov rD, r18
  485.     mov rB, r18
  486.     mov rC, r18
  487.     out PORTC, rC
  488.     out PORTB, rB
  489.     out PORTD, rD
  490. //Iteration
  491.     adiw Y, 1
  492.     subi r19, -1
  493.     //lägg till register som "klocka"
  494.  
  495.  
  496.    
  497.     //onödig loop för tillfället
  498.  
  499.     cpi r19, 8
  500.     brne nojump
  501.  
  502.     rjmp start
  503.  
  504.  
  505. nojump:
  506.     rjmp loop
  507.  
  508.  
  509.  
  510. ADSCWait:
  511.  
  512.     ;wait until adsc bit becomes 0
  513.     lds r16, ADCSRA
  514.     SBRC r16, 6
  515.     jmp ADSCWait
  516.     ret
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top