/*
  PONG in ASM
   Final project for https://hackaday.io/course/176685-avr-architecture-assembly-reverse-engineering
 
*/

avr-pong.ino

Build a PONG game in AVR Assembly.

See [the Hackaday Project Page] for instructions.


README.md

diagram.json

;;; "PONG" in AVR assembly

; V0.2 - show a bouncing ball
; V0.3 - -"-  and  move NPC bat
; V0.4 - -"-  and  Read buttons - move player bat
; V0.5 - -"-  and  End Game detection
; ToDo / Improve
;   Button input allows for several presses within one ball-advance
; Show Off more AVR/Assembly
;   Interrupt (like SPI transfer done)
; Make game more interesting... (and the code a LOT longer)
;   More than 45 degree angles for the bounce, somehow related to "spin" of ball
;   Speed increases as game progresses
;   Make NPC impossible to beat, with counter for how long player kept up

#define __SFR_OFFSET 0 // makes "PORTB" etc fit the IN/OUT Port, instead of the memory equivalent
#include <avr/io.h>    // Get the "basic" symbolic names for registers
.global main           ; Interface to the Arduino/C startup
                       ; (therefore?) stackpointer and vector table initialized

; additional hardware defines (The SPI is given)
CSS = PB2               ; MASK for Arduino pin 10 (portB, pin 2) is the CSS line
UP_N = 7                ; bit number for Arduino pin 7, the UP button
UP  = 1<<UP_N           ; MASK for same
DWN_N = 6               ; bit number for Arduino pin 6, the UP button
DWN = 1<<DWN_N          ; MASK for same

DispSegs = 2            ; number of display segments (could be between 2 and 6)
RowLow = 1              ; lowest display row# (but is at the top)
RowHig = 8              ; highest             (              bottom)
ColLft = 0              ; leftmost display column
ColRgt = DispSegs*8-1   ; right

// This uses the fact we are preprocessed and thus can "rename" registers
// register assigments/equivalence for variables
#define Xpos r18        // [0..15]
#define Ypos r19        // [1..8]
#define Xdir r5         // 0 = left, 1 = right (ie 0 is decrementing, 1 is incrementing)
#define Ydir r6         // 0 = up, 1 = down
#define Speed r7        // number of deci-seconds between moves, call it "slowness" instead

#define CurLin r23      // current line we're displaying
#define LinBuf r8       // current line segment
#define LinBuf2 r9      //  2nd half, BUT that hardcodes us to 2 seg only

#define Tmp r16         // for single byte stuff
#define Tmp2 r20        // for double byte stuff, ie includes r21, also just the one byte
#define Tmp2u r21       // the upper byte of Tmp2
#define Tmp3 Tmp2u      // could also be 3rd temp byte

#define One  r1         // "constant"

; ####### Data area ###### (stored in SRAM, starts above the register area)
       .data

;(mostly just to test load/store from SRAM instructions)
tmr1:  .word  0         ; A "timer"
bats:  .byte  0         ; bat positions (center [2-7]), one nibble for each
                        ; bit 4 in top nibble is direction (as position never exceeds 7)

; extended version will have the display buffer in SRAM to allow for more display units)

; ###### Code area ########  (Storing code in flash)
       .text

; ==== send one byte-pair to display (partial transaction) 
SendTwo:
   ; entry: byte values in Tmp2/3 (r20/21)
   ; exit: Tmp altered
   out   SPDR,Tmp2       ; send the first byte, the row - put it in SPI data register
1: in    Tmp,SPSR        ; Read SPI status register 
   sbrs  Tmp,SPIF        ; was the done bit set ?
   rjmp  1b              ; nope, keep waiting

   out   SPDR,Tmp3       ; 2nd byte Display pattern - send it too
1: in    Tmp,SPSR        ; Read SPI status register 
   sbrs  Tmp,SPIF        ; was the done bit set ?
   rjmp  1b              ; nope, keep waiting

   ret

; ===== send one row to display
SendRow:
   ; Push four bytes to SPI, bracket by LOW pin 10
   ; Entry: CurLin contains rownumber
   ;        LinBuf/LinBuf2 is display image row
   ; Exit:  Tmp, Tmp2 altered
   cbi   PORTB,CSS       ; Trigger a "new transaction" on MAX7219 (pin 10 LOW)
   mov   Tmp2,CurLin     ; 
   mov   Tmp2u,LinBuf    ; first part of display (left)
   rcall SendTwo
   mov   Tmp2u,LinBuf2   ; second part of display (right)
   rcall SendTwo
   sbi   PORTB,CSS       ; pin 10 HIGH again
   ret


; ==== wait for N centi-seconds (1..255). 
delayCenti:
   ; entry: Value in R20/tmp2, but only using the byte
   ; exit: no change to registers
   push  r20             ; save registers
   push  r26             
   push  r27

   ; loop for one centisecond consuming 160000 cycles
2: ldi r26,lo8(40000)     ; 1/4 of cycles needed
   ldi r27,hi8(40000)     ; as the loop consumes 4 cycles
1:
   sbiw r26,1             ; count loops done
   brne 1b
  
   dec  r20               ; count required number
   brne 2b
  
   pop r27               ; restore and return
   pop r26
   pop r20
   ret

; ==== check if bat is visible, or on bat, ie does it match CurLin +/- 1
batchk:
   ; entry: low nibble of Tmp = bat pos (must be in 2-7 range)
   ; exit: Z set if "visible"/"strike", all registers preserved
   push  Tmp
   andi  Tmp,0b00000111  ; only look at the low 3 bits
   dec   Tmp
   cp    Tmp,CurLin      ; does it match the top?
   breq  1f
   inc   Tmp             ; no, middle?
   cp    Tmp,CurLin
   breq  1f
   inc   Tmp
   cp    Tmp,CurLin      ; no, bottom?
1: pop   Tmp
   ret                   ; Z set if there was a match

; =====================
main: ; START HERE ====
; =====================

   ; === Initialisation, one time ===

   ; --- CPU related ( stack and vectors are initialised by infrastructure )

   cli                  ; we live without interrupts
   clr  One             ; a usefull number
   inc  One             ; as register constant
  
   ; ---- Setup SPI mode
   ldi  Tmp,0B00101100  ; bit 2, 3 and 5 for Arduino pins 10, 11 and 13 as OUTPUT
   out  DDRB,Tmp        ;   the rest as INPUT
   ldi  Tmp,0B00000100  ; Bit 2/pin 10
   out  PORTB,Tmp       ;   HIGH
   ldi  Tmp,0B01010001  ; Bit 0 enable SPI, bit 5 to ?, bit 7 to ?
   out  SPCR,Tmp        ; Set these on the SPI control register

   ; ---
   ldi  Tmp,UP|DWN      ; button inputs
   out  PORTD,Tmp       ; now have resistor pullup 

   ; ---- Setup variables (well, just some non-zero startup value for now)

   mov  Xdir,One        ; initial move left
   clr  Ydir            ;    and up
   ldi  Tmp,11
   mov  Xpos,Tmp        ; set position of ball
   ldi  Tmp,4
   mov  Ypos,Tmp
   ldi  Tmp,20           ; Set speed to N centi seconds
   mov  Speed,Tmp        ; 
 
   ; --- Memory variables ( ditto )
   clr  Tmp              ; zero the timer
   sts  tmr1,Tmp
   sts  tmr1+1,Tmp
   ldi  Tmp,0x53         ; initial bat position
   sts  bats,Tmp

   rjmp Disp             ; start where the row is displayed
   
; ==========
loop: ; ==== round and round we go ...
; ==========

   ; === Adjust ball position

   ; --- handle bounce at edges, and signal EndOfGame

   mov   CurLin,Ypos     ; current ball vertical position

   ldi   Tmp,1
   cpi   Xpos,ColLft     ; reached left edge?
   brne  1f
   mov   Xdir,Tmp        ; yes, switch Xdir to 1
   lds   Tmp,bats        ; get player batposition
   rcall batchk          ; see if we're on the bat
   breq  1f              ;yep !
   rjmp   EndOfGame

1: cpi   Xpos,ColRgt     ; reached right edge?
   brne  1f
   clr   Xdir            ; yes, switch Xdir to 0
   lds   Tmp,bats        ; check NPC bat
   swap  Tmp
   rcall batchk          ; is it hitting the ball?
   breq  1f              ; yes
   jmp   EndOfGame

1: cpi   Ypos,RowLow     ; reached top(low number) row?
   brne  1f
   mov   Ydir,Tmp        ; yes, switch Ydir to 1
1: cpi   Ypos,RowHig     ; reached bottom(high) row ?
   brne  1f
   clr   Ydir
1: ; ball direction  adjusted

   ; --- move ball to new position

   ldi   Tmp,1
   sbrs  Xdir,0          ; left or right? (bit 0 set means right, increment)
   neg   Tmp             ; want negative adjustment
   add   Xpos,Tmp        ; adjust position
   ldi   Tmp,1
   sbrs  Ydir,0          ; down or up? (bit 0 set means down, increment)
   neg   Tmp             ; want negative adjustment
   add   Ypos,Tmp        ; adjust position

   ; === Adjust NPC bat. Oscillates in the middle (stupid NPC so player can win)

   ; inc-/dec-rement the right bat 
   lds   Tmp2,bats       ; current bat positions
   mov   Tmp,Tmp2        ; get workcopy
   swap  Tmp             ; extract the 3..6 number
   andi  Tmp,0b00000111 
   sbrs  Tmp2,7          ; is the top bit set?
   rjmp  1f              ; no, so go to the increment

   dec   Tmp             ; decrement (go up)
   cpi   Tmp,3           ; reached top, minus one
   brne  2f
   cbr   Tmp2,0b10000000 ; change direction (clear direction bit)
   rjmp  2f

1: inc   Tmp             ; incrementing (go down)
   cpi   Tmp,6           ; reached bottom, minus one?
   brne  2f
   sbr   Tmp2,0b10000000  ; change direction (set direction bit)

2: swap  Tmp              ; Store new bat position again
   andi  Tmp2,0b10001111  ; make room for the 3 position bits
   or    Tmp2,Tmp         ; put them in
   sts   bats,Tmp2        ; 
   

   ; === Get buttons, adjust player bat ===

   ; This code "cheats". 
   ; It relies on the slow update of the display for debounce

   lds   Tmp2,bats        ; get the 2..7 number of player bat
   in    Tmp3,PIND        ; get buttons
   com   Tmp3             ; Inverse

   ; check UP button

   mov   Tmp,Tmp3
   sez
   sbrs  Tmp,DWN_N        ; Check if DWN is pushed
   andi  Tmp,UP           ;  ditto UP   
   breq  1f               ; either Down is pushed or up is not pushed

break
   mov   Tmp,Tmp2
   andi  Tmp,0b00000111   
   cpi   Tmp,2            ; are we at top?
   breq  3f
   dec   Tmp              ; no, go up further
   rjmp  2f              

   ; check Down button

1: mov   Tmp,Tmp3
   sbrs  Tmp,UP_N         ; check that UP is pressed
   andi  Tmp,DWN          ; and down is not
   breq  3f

   mov   Tmp,Tmp2
   andi  Tmp,0b00000111   
   cpi   Tmp,7            ; are we at bottom?
   breq  3f
   inc   Tmp              ; no, go down further
   
2: andi  Tmp2,0b11111000  ; 
   or    Tmp2,Tmp
   sts   bats,Tmp2        ; store new position
3:
   ; === check win/loose (and display what?)

   ; --- TBW ---

   ; === Update display ===

Disp:
   mov   CurLin,One      ; for loop 1 thru 8
1: ;
   clr   LinBuf          ; empty display buffer line
   clr   LinBuf2

   ; --- place ball

   cp    Ypos,CurLin     ; Is ball on this line?
   brne  4f
   inc   LinBuf          ; set bit0 (cant ldi into LinBuf (stupid register choice))
   mov   Tmp,Xpos        ; the column ball is on
   tst   Tmp
2: breq  3f              ; have we moved it far enough to the left?
   lsl   LinBuf          ; no, give it a nudge
   rol   LinBuf2         ;   carry into next byte
   dec   Tmp             ; count
   rjmp  2b              ;       and loop
3: ;LinBuf/2 contains ball (or not)

4: ; --- display bats

   lds   Tmp,bats        ; check player bat, get position
   rcall batchk
   brne  5f              ; not visible
   ldi   Tmp,0B0000001   ; visible, set appropiate bit
   or    LinBuf,Tmp
5: lds   Tmp,bats        ; check bat 2 (high nibble)
   swap  Tmp 
   rcall  batchk
   brne   6f             ; not vible
   ldi    Tmp,0B10000000 ; visible, set appropiate bit
   or     LinBuf2,Tmp
6:
   ; --- send rowbuffer to display, next row
   
   rcall SendRow          ; output to display
   
   inc   CurLin           ; (for loop 1 thru 8)
   ldi   Tmp,8
   cp    Tmp,CurLin
   brsh  1b               ; at least one more row to go

   ; === End main loop

   ; --- wait
   mov    r20,Speed
   rcall  delayCenti

   ; --- (fake) timer
   lds    Tmp,tmr1        ; fake timer, just inc it
   inc    Tmp
   sts    tmr1,Tmp
   brne   1f              ; (Z is like carry for INC) 
   lds    Tmp,tmr1+1      ; propagate carry to next byte
   inc    Tmp
   sts    tmr1+1,Tmp
1:
   ; ---- What comes around goes around
   jmp   loop             ; (rjmp would be enough ... but it is a long way back)

EndOfGame:
; and thus, a long time together goes to an end.
   ldi    r20,50           ; half a second delay
   rcall  delayCenti
   ldi    CurLin,8
   clr    LinBuf
   clr    LinBuf2
1: rcall  SendRow           ; clear screen
   dec    CurLin
   brne   1b
   ser    Tmp
   mov    LinBuf,Tmp
   mov    LinBuf2,LinBuf
   ldi    CurLin,4
   rcall  SendRow

 99: ; twiddle thumbs
   nop
   rjmp 99b