/*

  PONG in AVR assembly

  ┍━━━━━━━━━━━━━━━━━━━━━━━━━━━━┑
  │	Write your code in pong.S  │
  ┕━━━━━━━━━━━━━━━━━━━━━━━━━━━━┙

  Keep this file empty!

  use A and D to move

*/

avr-pong.ino

Build a PONG game in AVR Assembly.

See [the Hackaday Project Page] for instructions.


README.md

diagram.json

; Write your code in this file

.global main
.global __do_copy_data

.data

; player and opponent can have values 1-14 for valid positions
; paddles are 3 pixels wide
; ball_pos is the offset into the array
; ball_dir is a bitmask to tell which direction to go. 1 is up, then clockwise. 
; 3 and 7 are not valid bits. 

ball_pos: .byte 0
ball_dir: .byte 0
field: .space 32

.text

; "#defines"
.EQU PORTB, 0x05
.EQU PORTD, 0x0B
.EQU PIND, 0x09
.EQU DDRB, 0x04
.EQU SPCR, 0x2C
.EQU SPSR, 0x2D
.EQU SPDR, 0x2E

.EQU LEFT, 1
.EQU RIGHT, 2
.EQU PLAYER, 0
.EQU OPP, 1

; http://www.rjhcoding.com/avr-asm-8bit-division.php
; modified by jdavis to compile
;***************************************************************************
;*
;* "div8u" - 8/8 Bit Unsigned Division
;*
;* This subroutine divides the two register variables "dd8u" (dividend) and
;* "dv8u" (divisor). The result is placed in "dres8u" and the remainder in
;* "drem8u".
;*
;* Number of words	:14
;* Number of cycles	:97
;* Low registers used	:1 (drem8u)
;* High registers used  :3 (dres8u/dd8u,dv8u,dcnt8u)
;*
;***************************************************************************

;***** Subroutine Register Variables

; .set	drem8u, r15		;remainder
; .set	dres8u, r16		;result
; .set	dd8u, r16		;dividend (top)
; .set	dv8u, r17		;divisor (bottom)
; .set	dcnt8u, r18		;loop counter

;***** Code

div8u:	sub	r15, r15	;clear remainder and carry
	ldi	r18, 9	;init loop counter
d8u_1:	rol	r16		;shift left dividend
	dec	r18		;decrement counter
	brne	d8u_2		;if done
	ret			;    return
d8u_2:	rol	r15		;shift dividend into remainder
	sub	r15,r17	;remainder = remainder - divisor
	brcc	d8u_3		;if result negative
	add	r15,r17	;    restore remainder
	clc			;    clear carry to be shifted into result
	rjmp	d8u_1		;else
d8u_3:	sec			;    set carry to be shifted into result
	rjmp	d8u_1

.MACRO SEND_BYTE_IMM input
  ldi r17, \input
  out SPDR, r17
1:
  in r16, SPSR
  sbrs r16, 7
  jmp 1b
.ENDM

.MACRO SEND_BYTE_REG input
  out SPDR, \input
1:
  in r16, SPSR
  sbrs r16, 7
  jmp 1b
.ENDM

.MACRO SEND_COMMAND_IMM cs, byte1, byte2, byte3, byte4
  CBI PORTB, \cs
  SEND_BYTE_IMM \byte1
  SEND_BYTE_IMM \byte2
  SEND_BYTE_IMM \byte3
  SEND_BYTE_IMM \byte4
  SBI PORTB, \cs
.ENDM

.MACRO SEND_COMMAND_REG cs, byte1, byte2, byte3, byte4
  CBI PORTB, \cs
  SEND_BYTE_REG \byte1
  SEND_BYTE_REG \byte2
  SEND_BYTE_REG \byte3
  SEND_BYTE_REG \byte4
  SBI PORTB, \cs
.ENDM

.MACRO CLEAR_TABLE cs
  SEND_COMMAND_IMM \cs, 0x01, 0x00, 0x01, 0x00
  SEND_COMMAND_IMM \cs, 0x02, 0x00, 0x02, 0x00
  SEND_COMMAND_IMM \cs, 0x03, 0x00, 0x03, 0x00
  SEND_COMMAND_IMM \cs, 0x04, 0x00, 0x04, 0x00
  SEND_COMMAND_IMM \cs, 0x05, 0x00, 0x05, 0x00
  SEND_COMMAND_IMM \cs, 0x06, 0x00, 0x06, 0x00
  SEND_COMMAND_IMM \cs, 0x07, 0x00, 0x07, 0x00
  SEND_COMMAND_IMM \cs, 0x08, 0x00, 0x08, 0x00
.ENDM

.MACRO GET_FIELD
  ldi r26, lo8(field)
  ldi r27, hi8(field)
.ENDM

.MACRO GET_BALL_POS
  ldi r26, lo8(ball_pos)
  ldi r27, hi8(ball_pos)
.ENDM

.MACRO GET_BALL_DIR
  ldi r26, lo8(ball_dir)
  ldi r27, hi8(ball_dir)
.ENDM

display_board:
  ; upper half
  GET_FIELD  
  ; upper half
  ldi r16, 1
  mov r1, r16
  ldi r16, 0 ; row counter
  ldi r17, 1
2:
  ld r18, X+ ; get the two values for this segment
  ld r20, X+
  push r16
  SEND_COMMAND_REG 1, r17, r18, r17, r20
  pop r16
  add r17, r1
  add r16, r1
  sbrs r16, 3
  jmp 2b
  ; lower half
  ldi r16, 0 ; row counter
  ldi r17, 1
2:
  ld r18, X+ ; get the two values for this segment
  ld r20, X+
  push r16
  SEND_COMMAND_REG 2, r17, r18, r17, r20
  pop r16
  add r17, r1
  add r16, r1
  sbrs r16, 3
  jmp 2b
  ret

; shamelessly stolen from @urish - https://wokwi.com/arduino/projects/291441550200668685
delay_millis:
  ; 16000 cycles
  ldi r26, 4000 & 0xff
  ldi r27, 4000 >> 8
1:
  sbiw r26, 1  ; 2 cycles
  brne 1b      ; 2 cycles 
  sbiw r24, 1
  brne delay_millis
  ret

.MACRO DELAY_M
  push r24
  push r26
  call delay_millis
  pop r26
  pop r24
.ENDM

; r16 is which paddle, player = 0, opp = 1
; r17 is direction. 0 = none, 1 = left, 2 = right
; left is right and right is left. 
show_paddle:
  push r24
  push r25

  GET_FIELD
  sbrc r16, 0
  jmp 1f ; skip if not player
  ldi r24, 30
  add r26, r24
1:
  ; determine shift direction
  sbrs r17, 0
  jmp 2f
  ; going left
  ; make sure we can go left
  ld r24, X+
  ld r25, X+
  sbrc r24, 0
  jmp paddle_end
  ; we can move left
  ; reset carry bit
  clc
  lsr r24
  lsr r25
  ; if carry is set, add it to the high bit of r24
  brcc 1f
  ori r24, 0b10000000
1:
  st -X, r25
  st -X, r24
  jmp paddle_end
2:
  sbrs r17, 1
  jmp paddle_end
  ; going right
  ; make sure we can go right
  ld r24, X+
  ld r25, X+
  sbrc r25, 7
  jmp paddle_end
  ; we can move left
  clc
  lsl r25
  lsl r24
  brcc 1f
  ori r25, 1
1:
  st -X, r25
  st -X, r24
paddle_end:
  pop r25
  pop r24
  ret

; sets up the pins
init:
  ; button init
  ldi r16, 0xff
  out PORTD, r16
  ; SPI init
  sbi DDRB, 5 ; MOSI is output
  sbi DDRB, 7 ; SCK as output
  sbi DDRB, 1 ; CS pin
  sbi DDRB, 2 ; CS pin
  ; drive CS pins HIGH
  SBI PORTB, 0x1
  SBI PORTB, 0x2
  ; set up SPI
  ldi r16, 0b01010000 ; master, interrupt disabled
  in r17, SPCR
  or r17, r16
  out SPCR, r17

  ; init displays
  SEND_COMMAND_IMM 1, 0x0f, 0x00, 0x0f, 0x00
  SEND_COMMAND_IMM 1, 0x0b, 0x07, 0x0b, 0x07
  CLEAR_TABLE 1
  SEND_COMMAND_IMM 1, 0x0c, 0x01, 0x0c, 0x01
  SEND_COMMAND_IMM 2, 0x0f, 0x00, 0x0f, 0x00
  SEND_COMMAND_IMM 2, 0x0b, 0x07, 0x0b, 0x07
  CLEAR_TABLE 2
  SEND_COMMAND_IMM 2, 0x0c, 0x01, 0x0c, 0x01
  ret

add_paddles:
  GET_FIELD

  ldi r24, 0b10000000
  ldi r25, 0b00000011
  st X+, r24
  st X, r25

  ldi r23, 29
  add r26, r23

  st X+, r24
  st X, r25
  ret

add_ball:
  GET_BALL_POS
  ldi r16, 232
  st X, r16

  ; r16 is dividend
  ldi r17, 8 ; divisor
  call div8u

  GET_FIELD
  add r26, r16 ; result is in r16, remainder in r15
  ldi r24, 1
2:
  tst r15
  brne 1f
  jmp 2f
1:
  lsl r24
  dec r15
  jmp 2b
2:
  st X, r24

  GET_BALL_DIR
  ldi r24, 2
  st X, r24

  ret

move_ball:
  push r15
  push r16
  push r17
  push r18
  push r20
  push r21
  push r22

  ; start by getting ball location and direction
  GET_BALL_POS
  ld r20, X
  GET_BALL_DIR
  ld r21, X

  ; need to check if the next location is valid
  mov r16, r20
  ldi r17, 8
  call div8u
  ; r16 has slot
  ; r15 has remainder
  ; remove ball from board to be drawn
  GET_FIELD
  add r26, r16
  ldi r22, 0
  st X+, r22
  ; case on right
  sbrs r16, 0 ; if we are on the right half of the screen
  jmp 2f
  ldi r22, 7
  cp r15, r22 ; if we are against the wall
  brne 3f
  sbrs r21, 1 ; if we are traveling up
  jmp 1f
  ldi r21, 0x80 ; reverse direction
  jmp 3f
1: ; we are traveling down
  ldi r21, 0x20 ; reverse direction
  jmp 3f
2:
  ; now check for left wall
  ldi r22, 0
  cp r15, r22 ; if we are on the left wall
  brne 3f
  sbrs r21, 7 ; if we are traveling up
  jmp 1f
  ldi r21, 0x02 ; reverse direction
  jmp 3f
1: ; we are traveling down
  ldi r21, 0x08 ; reverse direction
3:
  ; our direction is now accurate for where we want to go next
  ; are we traveling upwards
  cpi r21, 0x80
  brne 3f
  clc
  ldi r22, 1
  sub r15, r22 ; yes, and we are moving to the left. move the ball up and to the left.
  brcc 1f
  ldi r22, 7
  mov r15, r22
  subi r16, 3 ; we moved to the left half
  jmp post_calc
1:
  subi r16, 2 ; we stayed in the same half
  jmp post_calc
3:
  ; are we traveling upwards
  cpi r21, 0x02
  brne 2f
  ldi r22, 1
  add r15, r22 ; yes, and we are moving to the right. move the ball up and to the right
  ldi r22, 8
  cp r15, r22
  brne 1f
  ldi r22, 0
  mov r15, r22
  subi r16, 1 ; we moved to the right half
  jmp post_calc
1:
  subi r16, 2 ; we stayed in the same half
  jmp post_calc
2:
  ; are we traveling downwards
  cpi r21, 0x20
  brne 2f
  ldi r22, 1
  sub r15, r22 ; yes, and we are moving to the left. move the ball down and to the left.
  brcc 1f
  ldi r22, 7
  mov r15, r22
  ldi r22, 1
  add r16, r22 ; we moved to the left half
  jmp post_calc
1:
  ldi r22, 2
  add r16, r22 ; we stayed in the same half
  jmp post_calc
2:
  ; are we traveling downwards
  cpi r21, 0x08
  brne post_calc
  ldi r22, 1
  add r15, r22 ; yes, and we are moving to the right. move the ball down and to the right.
  ldi r22, 8
  cp r15, r22
  brne 1f
  ldi r22, 0
  mov r15, r22
  ldi r22, 3
  add r16, r22 ; we moved to the right half
  jmp post_calc
1:
  ldi r22, 2
  add r16, r22 ; we stayed in the same half
; ball has new position - is it where a paddle is?
post_calc:
  mov r4, r15
  ldi r22, 1
  mov r5, r22
1:
  tst r4
  breq 1f
  clc
  lsl r5
  sub r4, r22
  jmp 1b
1:
  GET_FIELD
  add r26, r16
  ld r0, X+
  and r0, r5
  tst r0 ; if there is a paddle there
  brne hit_paddle
  ; check if we are on the top or bottom row
  ldi r22, 30
  cp r16, r22
  brlt 1f
  jmp game_over
1:
  ldi r22, 2
  cp r16, r22
  brge commit
  ; game over
  jmp game_over
hit_paddle:
  ; need to switch direction, and move the paddle up/down two rows
  cpi r21, 0x80 ; currently up and to left
  brne 1f
  ; move down two rows
  ldi r22, 4
  add r16, r22
  ; switch directions
  ldi r21, 0x20
  jmp commit
1:
  cpi r21, 0x02 ; currently up and to right
  brne 1f
  ; move down two rows
  ldi r22, 4
  add r16, r22
  ; switch directions
  ldi r21, 0x08
  jmp commit
1:
  cpi r21, 0x20 ; currently down and to left
  brne 1f
  ; move down two rows
  subi r16, 4
  ; switch directions
  ldi r21, 0x80
  jmp commit
1:
  cpi r21, 0x08 ; currently down and to right
  brne 1f
  ; move down two rows
  subi r16, 4
  ; switch directions
  ldi r21, 0x02
  jmp commit
1:
commit:
  ; update ball position and direction
  GET_BALL_DIR
  st X+, r21
  mov r0, r16
  mov r2, r16 ; save for later.
  ldi r16, 8
  mul r16, r0
  mov r16, r0
  add r16, r15
  GET_BALL_POS
  st X+, r16
  ; new ball position stored, but we need to redraw the ball on the board
  GET_FIELD
  add r26, r2 ; later.
  ldi r22, 1
  mov r0, r22
1:
  tst r15
  breq 1f
  clc
  lsl r22
  sub r15, r0
  jmp 1b
1:
  st X+, r22

  pop r22
  pop r21
  pop r20
  pop r18
  pop r17
  pop r16
  pop r15
  ret

move_opp:
  push r0
  push r16
  push r17

  GET_BALL_DIR
  ld r16, X+
  ; if ball is moving left, we move left
  cpi r16, 0x80
  breq opp_left
  cpi r16, 0x20
  breq opp_left
  ; if ball is moving right, we move right
  jmp opp_right
opp_left:
  ldi r16, OPP
  ldi r17, LEFT
  call show_paddle
  jmp opp_end
opp_right:
  ldi r16, OPP
  ldi r17, RIGHT
  call show_paddle
opp_end:
  pop r17
  pop r16
  pop r0
  ret

main:
  call init
  call add_paddles
  call add_ball
  ldi r24, lo8(2000)
  ldi r25, hi8(2000)
loop:
  call display_board
  ldi r16, 0
  ldi r17, 1
  in r24, PIND
  sbis PIND, 7 ; move left
  jmp 1f
  ldi r16, PLAYER
  ldi r17, LEFT
  call show_paddle
1:
  sbis PIND, 6 ; move right
  jmp 1f
  ldi r16, PLAYER
  ldi r17, RIGHT
  call show_paddle
1:
  call move_ball
  call move_opp
  DELAY_M
  jmp loop

game_over:
  CLEAR_TABLE 1
  CLEAR_TABLE 2
1:
  jmp 1b