SHARE
TWEET

Untitled

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