SHARE
TWEET

Untitled

a guest May 21st, 2019 70 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. .DEF rTemp         = r20
  2. .DEF rDirection    = r21
  3.  
  4. .DEF rD = r23
  5. .DEF rB = r24
  6. .DEF rC = r25
  7. .DEF i0 = r0 //immidiate 0
  8. .DEF i1 = r1 //immidiate 1
  9. .DEF i2 = r2 //immidiate 2
  10. .DEF i4 = r3 //immidiate 4
  11. .DEF i8 = r4 //immidiate 8
  12. .DEF i16 = r5 //immidiate 16
  13. .DEF i32 = r6 //immidiate 32
  14.  
  15. .DEF length = r10
  16. .DEF snakePos = r15
  17.  
  18. .DEF rRow = r22
  19.  
  20. .DSEG
  21.     matrix:   .BYTE 8
  22.    
  23.     interupt: .BYTE 1
  24.  
  25. .CSEG
  26. // Interrupt vector table
  27. .ORG 0x0000
  28.      jmp init // Reset vector
  29.  
  30. .ORG 0x0020
  31. jmp isr_timerOF // Timer 0 overflow vector
  32.      
  33. //... fler interrupts
  34. .ORG INT_VECTORS_SIZE
  35.  
  36.     //interrupt handler for timer
  37. isr_timerOF:
  38.     push r18
  39.     ldi r18, 1
  40.     st X, r18
  41.     pop r18
  42.     reti
  43.      
  44.  
  45. init:
  46.      // Sätt stackpekaren till högsta minnesadressen
  47.      ldi rTemp, HIGH(RAMEND)
  48.      out SPH, rTemp
  49.      ldi rTemp, LOW(RAMEND)
  50.      out SPL, rTemp
  51.      
  52.      ldi XH, HIGH(interupt)
  53.      ldi XL, LOW(interupt)
  54.  
  55.      ldi r16, 0b11001111
  56.      out DDRC, r16
  57.  
  58.      ldi r16, 0b11111111
  59.      out DDRD, r16
  60.  
  61.      ldi r16, 0b11111111
  62.      out DDRB, r16
  63.    
  64.  
  65.      //sätter värdet på olika icke-immediate register så att vi kan lättare få tillgång till användbara siffror
  66.      sub r0, r0
  67.      ldi r18, 1
  68.      mov r1, r18
  69.      ldi r18, 2
  70.      mov r2, r18
  71.      ldi r18, 4
  72.      mov r3, r18
  73.      ldi r18, 8
  74.      mov r4, r18
  75.      ldi r18, 16
  76.      mov r5, r18
  77.      ldi r18, 32
  78.      mov r6, r18
  79.        
  80.      mov r10, r0
  81.  
  82.      ldi r18, 0b00110000
  83.      mov snakePos, r18
  84.      //Global Interrupt Enable
  85.      sei
  86.  
  87.      //Enable Timer Interrupt
  88.      ldi r18, 0b00000001
  89.      sts TIMSK0, r18
  90.      
  91.      //  A/D Omvandlare
  92.      ldi r16, 0b01000000
  93.      sts ADMUX, r16
  94.  
  95.      ldi r16, 0b10000111
  96.      sts ADCSRA, r16
  97.  
  98.      mov r17, i0
  99.      //
  100.        // Första fyra bitarna representerar analog input 4 (y axeln)
  101.     ldi r16, 0b01000010
  102.     sts ADMUX, r16
  103.  
  104.     //Sätter bit 6 till 1. För att starta omvandling
  105.     ldi r16, 0b11100011
  106.     sts ADCSRA, r16
  107.  
  108.     mov r7, i0
  109.  
  110.  
  111.  
  112.  
  113. start:
  114.     //Laddar in matrisen "matrix" i Y
  115.     ldi YH, HIGH(matrix)
  116.     ldi YL, LOW(matrix)
  117.     ldi r19, 0
  118.     //st Y, i0
  119.  
  120.     //Skriv spel logik här  vvvvv
  121.  
  122.     //tar fram X värdet från snakePos och pushar den till bitarna längst till höger
  123.     ldi r16, 0b11110000
  124.     and r16, snakePos
  125.     LSR r16
  126.     LSR r16
  127.     LSR r16
  128.     LSR r16
  129.  
  130.     //tar fram Y värdeet från snakePos
  131.     ldi r17, 0b00001111
  132.     and r17, snakePos
  133.  
  134.     //itererar ner till rätt rad i Y värdet
  135. miniy:
  136.     cp r17, i0
  137.     breq miniyend
  138.     sub r17, i1
  139.     adiw Y, 1
  140.  
  141.     jmp miniy
  142.  
  143. miniyend:
  144.  
  145.  
  146.     //itererar till rätt X värde i kolumnen
  147.     ldi r18, 0b10000000
  148. minix:
  149.     cp r16, i0
  150.     breq minixend
  151.     sub r16, i1
  152.     LSR r18
  153.     jmp minix
  154.  
  155. minixend:
  156.     ld r17, Y
  157.     and r18, r17
  158.     st Y, r18
  159.  
  160.     ldi YH, HIGH(matrix)
  161.     ldi YL, LOW(matrix)
  162.  
  163.     //ser till att vi loopar alla rader 32 gånger innan den kör spel logiken igen
  164.     add r7, i1
  165.     cp r7, i32
  166.     breq loop
  167.  
  168.     mov r7, i0 
  169.  
  170.     /*
  171.     ldi r18, 0b10000001
  172.     st Y+, r18
  173.     //adiw Y, 1
  174.     ldi r18, 0b01000010
  175.     st Y+, r18
  176.     //adiw Y, 1
  177.     ldi r18, 0b00100100
  178.     st Y+, r18
  179.     //adiw Y, 1
  180.     ldi r18, 0b00000000
  181.     st Y+, r18
  182.     //adiw Y, 1
  183.     ldi r18, 0b0011000
  184.     st Y+, r18
  185.     //adiw Y, 1
  186.     ldi r18, 0b00100100
  187.     st Y+, r18
  188.     //adiw Y, 1
  189.     ldi r18, 0b01000010
  190.     st Y+, r18
  191.     //adiw Y, 1
  192.     ldi r18, 0b10000001
  193.     st Y, r18*/
  194.  
  195.     //                      ^^^^^
  196.     ldi YH, HIGH(matrix)
  197.     ldi YL, LOW(matrix)
  198.  
  199. loop:
  200.     //Skriver r18 till en plats i Y
  201.     //Detta stycket borde också finnas med i spel logiken senare
  202.     ldi r20, 0b00000011
  203.     out TCCR0B, r20
  204.     ld rRow, Y
  205.     mov rD, rRow
  206.  
  207.  
  208.    
  209.    
  210.     add r11, i1
  211.     cp r11, i8
  212.     brne dontset0
  213.  
  214.     mov r1, i0
  215.    
  216.  
  217. dontset0:
  218.     //Byter plats på bits. 7 är vänster, 0 är höger
  219.     bst rRow, 7
  220.     bld rD, 6
  221.     bst rRow, 6
  222.     bld rD, 7
  223.  
  224.     bst rRow, 5
  225.     bld rD, 0
  226.     bst rRow, 0
  227.     bld rD, 5
  228.  
  229.     bst rRow, 4
  230.     bld rD, 1
  231.     bst rRow, 1
  232.     bld rD, 4
  233.  
  234.     bst rRow, 3
  235.     bld rD, 2
  236.     bst rRow, 2
  237.     bld rD, 3
  238.  
  239.  
  240.     //Kopierar rD till rB
  241.     mov rB, rD
  242.  
  243.     //sparar de relevanta bitsen i rD till portD
  244.     andi rD, 0b11000000
  245.    
  246.     //sparar de relevanta bitsen i rB till portB
  247.     andi rB, 0b00111111
  248.    
  249.  
  250.  
  251. //Start av indexering
  252. //Switch case funktion gör olika saker beroende på vilken rad
  253. index0:
  254.     cpi r19, 0
  255.     brne index1
  256.        
  257.     ldi rC, 0b00000001
  258.  
  259.     rjmp indexEnd
  260. index1:
  261.     cpi r19, 1
  262.     brne index2
  263.  
  264.     ldi rC, 0b00000010
  265.  
  266.     rjmp indexEnd
  267. index2:
  268.     cpi r19, 2
  269.     brne index3
  270.  
  271.     ldi rC, 0b00000100
  272.  
  273.     rjmp indexEnd
  274. index3:
  275.     cpi r19, 3
  276.     brne index4
  277.  
  278.     ldi rC, 0b00001000
  279.  
  280.     rjmp indexEnd
  281. index4:
  282.     cpi r19, 4
  283.     brne index5
  284.  
  285.     ori rD, 0b00000100
  286.  
  287.     rjmp indexEnd
  288. index5:
  289.     cpi r19, 5
  290.     brne index6
  291.  
  292.     ori rD, 0b00001000
  293.  
  294.     rjmp indexEnd
  295. index6:
  296.     cpi r19, 6
  297.     brne index7
  298.  
  299.     ori rD, 0b00010000
  300.  
  301.     rjmp indexEnd
  302. index7:
  303.     cpi r19, 7
  304.     brne indexEnd
  305.  
  306.     ori rD, 0b00100000
  307.  
  308. indexEnd:
  309.  
  310.     //Tänder lampor
  311.     out PORTD, rD
  312.     out PORTB, rB
  313.     out PORTC, rC
  314.  
  315. noppp:
  316.     ld r8, X
  317.     cp r8, i0
  318.     breq noppp
  319.     st X, i0
  320.  
  321.     //rensar alla lampor
  322.     ldi r18, 0b00000000
  323.     mov rD, r18
  324.     mov rB, r18
  325.     mov rC, r18
  326.     out PORTC, rC
  327.     out PORTB, rB
  328.     out PORTD, rD
  329. //Iteration
  330.     adiw Y, 1
  331.     subi r19, -1
  332.     //lägg till register som "klocka"
  333.  
  334.  
  335.    
  336.     //onödig loop för tillfället
  337.  
  338.     cpi r19, 8
  339.     brne nojump
  340.  
  341.     rjmp start
  342.  
  343.  
  344. nojump:
  345.     rjmp loop
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