6502.org

Code: Select all

  lda next+head
  tay ; we'll need this again later
  sta next, x                    ; key.next = old head.next
  lda #head
  sta prev, x                    ; key.prev = head
  txa
  sta prev, y                    ; head.next.prev = key
  sta next+head              ; head.next = key

Code: Select all

  lda next, x
  tay
  lda prev, x
  sta prev, y                     ; key.next.prev = old key.prev
  tax
  tya
  sta next, x                     ; key.prev.next = old key.next

Code: Select all

Initial state:
  next $ff $ff $ff $ff $03
  prev $ff $ff $ff $04 $ff
  (Head <-> Tail)
Press A:
  next $03 $ff $ff $ff $00
  prev $04 $ff $ff $00 $ff
  (Head <-> A <-> Tail)
Press B:
  next $03 $00 $ff $ff $01
  prev $01 $04 $ff $00 $ff
  (Head <-> B <-> A <-> Tail)
Press C:
  next $03 $00 $01 $ff $02
  prev $01 $02 $04 $00 $ff
  (Head <-> C <-> B <-> A <-> Tail)
Release B:
  next $03 $00 $00 $ff $02
  prev $02 $02 $04 $00 $ff
  (Head <-> C <-> A <-> Tail)

Code: Select all

	.section "vars"
numKeys = 3
tail = numKeys
head = numKeys+1
next	.space numKeys+2
prev	.space numKeys+2

	.section "code"

	bra.l init
	bra.l report

	ldr x0, #0
	bra.l insert
	bra.l report

	ldr x0, #1
	bra.l insert
	bra.l report

	ldr x0, #2
	bra.l insert
	bra.l report

	ldr x0, #1
	bra.l remove
	bra.l report

	bra *

init
{
	ldr a0, #$ff
	ldr x0, #numKeys+2
loop
	str a0, next, x0
	str a0, prev, x0
	dec x0
	bpl loop
	sti next+head, #tail
	sti prev+tail, #head
	rts
}

insert
{
	ldr a0, next+head
	mov y0, a0 ; we'll need this again later
	str a0, next, x0                    ; key.next = old head.next
	ldr a0, #head
	str a0, prev, x0                    ; key.prev = head
	mov a0, x0
	str a0, prev, y0                    ; head.next.prev = key
	str a0, next+head              ; head.next = key
	rts
}

remove
{
	ldr a0, next, x0
	mov y0, a0
	ldr a0, prev, x0
	str a0, prev, y0                     ; key.next.prev = old key.prev
	mov x0, a0
	mov a0, y0
	str a0, next, x0                     ; key.prev.next = old key.next
	rts
}

report
{
	brk 3, #syscall_print_inline_string
	.byte "next: ", 0
	ldr.l y0, #next
	bra.l printArray
	brk 3, #syscall_print_inline_string
	.byte "prev: ", 0
	ldr.l y0, #prev
	bra.l printArray

	ldr x0, #head
forwardLoop
	brk 3, #syscall_print_inline_string
	.byte char_reg_hex2+char_reg_x0, " ", 0
	ldr x0, next, x0
	cmp x0, #$ff
	bne forwardLoop
	brk 3, #syscall_print_inline_string
	.byte 13, 0

	ldr x0, #tail
backLoop
	brk 3, #syscall_print_inline_string
	.byte char_reg_hex2+char_reg_x0, " ", 0
	ldr x0, prev, x0
	cmp x0, #$ff
	bne backLoop
	brk 3, #syscall_print_inline_string
	.byte 13, 0

	rts
}

printArray
{
	ldr x0, #numKeys+2
loop
	ldr a0, 0, y0
	brk 3, #syscall_print_inline_string
	.byte char_reg_hex2+char_reg_a0, " ", 0
	inc.l y0
	dec x0
	bne loop
	brk 3, #syscall_print_inline_string
	.byte 13, 0
	rts
}

next: ff ff ff ff ff 03
prev: ff ff ff ff 04 ff
04 03
03 04
next: 03 ff ff ff 00
prev: 04 ff ff 00 ff
04 00 03
03 00 04
next: 03 00 ff ff 01
prev: 01 04 ff 00 ff
04 01 00 03
03 00 01 04
next: 03 00 01 ff 02
prev: 01 02 04 00 ff
04 02 01 00 03
03 00 01 02 04
next: 03 00 00 ff 02
prev: 02 02 04 00 ff
04 02 00 03
03 00 02 04

Code: Select all

        .space  CURNOTE      1      ; The index of the currently-playing key, or negative if none
        .space  KEYSTATES    76     ; Array showing last known states of all keys
        .space  KEYCHANGED   76     ; Array showing whether each key has changed state this scan

SCAN:       LDY #75
SCANLOOP:   LDA KYBD, Y             ; Read current state of key
            EOR KEYSTATES, Y        ; Compare against last known state
            STA KEYCHANGED, Y       ; Store whether it is different in separate array
            DEY
            BPL SCANLOOP

                                    ; An extra delay loop could be inserted here for more debouncing

            LDY #75
RESCANLOOP: LDA KEYCHANGED, Y       ; See if we thought this key changed state
            BNE CHANGED
NOCHANGE:   DEY                     ; No state change, go to next key
            BPL RESCANLOOP
            RTS                     ; Scan complete

CHANGED:    LDA KYBD, Y             ; Re-check the key, as a form of debouncing
            EOR KEYSTATES, Y
            BEQ NOCHANGE            ; Now it hasn't changed state, possibly it was a bouncing issue, ignore it

            EOR KEYSTATES, Y        ; Get back to the state of the key that was read at CHANGED
            STA KEYSTATES, Y        ; Update KEYSTATES entry

            BEQ RELEASE             ; If it was a release event, branch

            JSR KEYDOWN             ; Handle new pressed key
            BRA NOCHANGE            ; Return to the RESCAN loop

RELEASE:    JSR KEYUP               ; Handle released key
            BRA NOCHANGE            ; Return to the RESCAN loop



KEYUP:      CPY CURNOTE             ; Is this key the currently-playing note?
            BNE DIFFNOTE            ; If not, ignore the event
            JSR NOTEOFF             ; Tell synth to end the currently-playing note
            LDA #$FF
            STA CURNOTE             ; Mark that no note is currently playing
DIFFNOTE:   RTS



KEYDOWN:    LDA CURNOTE             ; Check if a note is playing
            BMI NONOTE
            JSR NOTEOFF             ; Tell synth to end the currently-playing note
NONOTE:     STY CURNOTE             ; Remember the new note
            JSR NOTEON              ; Tell synth to start the note
            RTS



NOTEON:     TYA
            ORA #$80
            STA REGEN               ; Turn gate on with key ID and D7=1
            RTS

NOTEOFF:    LDA CURNOTE
            STA REGEN               ; Turn gate off with key ID and D7=0
            RTS