John's Vademecum - public:computers:6502

6502 based homebrew computer

anonymous@undisclosed.example.com (Anonymous) — Wed, 24 Dec 2025 17:20:45 +0000

6502 based homebrew computer

— John Pumford-Green 17/09/22 12:29

I started a new project last month. I'd been thinking of what to use my new DM16L for, apart from simple Decimal to Hex to Binary conversions.

In a roundabout manner I found the work of Garth Wilson and his excellent resources for 6502 hardware and assembly-language. Then I found the excellent YouTube videos of Ben Eater and I was convinced that I needed to start building and learning 6502. I've always struggled with some aspects of software - it seems too abstract and not rooted in anything hard and physical. I found I enjoyed learning about machine code, and then Assembly, as it is tied very firmly to the hardware, you need to understand what happens on each clock cycle, where the data goes, how it can be manipulated.

And a DM16L calculator is right at home with the bit-twiddling needed to write code at the machine-code/assembly level. After all, the HP16 was originally designed for Programmers back when machine-code and bit-level programming was all there was!

I got a Ben Eater 6502 kit and haven't looked back.

I plan eventually to fix a hardware design, once I've experimented on Vero-board, and perhaps design some PCBs and build it “properly”….

6502 Project

6502

CA65 Setup

anonymous@undisclosed.example.com (Anonymous) — Tue, 30 Dec 2025 09:55:07 +0000

←6502 Project

CA65 Setup

Using CA65 in place of VASM

Support Files

firmware.cfg

MEMORY
{
# Zero page
  ZP: start = $00, size = $100, type = rw, define = yes;
  RAM: start = $200, size = $3dff define=yes;
  ROM:       start=$8000, size=$8000, type=ro, define=yes, fill=yes,   fillval=$00, file=%O;
}

SEGMENTS
{
  ZEROPAGE: load = ZP,             type = zp;
  BSS:        load=RAM,       type=bss, define=yes;
  
  CODE:      load=ROM,       type=ro,  define=yes;
  VECTORS:   load=ROM,       type=ro,  define=yes,   offset=$7ffa, optional=yes;
}

cc65.rules.mk

include /home/gm4slv/6502/ca65src/tools.mk
 
BUILD_FOLDER=../build
TEMP_FOLDER=$(BUILD_FOLDER)/$(ROM_NAME)
ROM_FILE=$(BUILD_FOLDER)/$(ROM_NAME).bin
MAP_FILE=$(TEMP_FOLDER)/$(ROM_NAME).map
 
ASM_OBJECTS=$(ASM_SOURCES:%.s=$(TEMP_FOLDER)/%.o)
 
# Compile assembler sources
$(TEMP_FOLDER)/%.o: %.s
	@$(MKDIR_BINARY) $(MKDIR_FLAGS) $(TEMP_FOLDER)
	$(CA65_BINARY) $(CA65_FLAGS) -o $@ -l $(@:.o=.lst) $<
 
# Link ROM image
$(ROM_FILE): $(ASM_OBJECTS) $(FIRMWARE_CFG)
	@$(MKDIR_BINARY) $(MKDIR_FLAGS) $(BUILD_FOLDER)
	$(LD65_BINARY) $(LD65_FLAGS) -C $(FIRMWARE_CFG) -o $@ -m $(MAP_FILE) $(ASM_OBJECTS)
 
# Default target
all: $(ROM_FILE)
 
# Build and dump output
test: $(ROM_FILE)
	$(HEXDUMP_BINARY) $(HEXDUMP_FLAGS) $<
	$(MD5_BINARY) $<
 
# Clean build artifacts
clean:
	$(RM_BINARY) -f $(ROM_FILE) \
	$(MAP_FILE) \
	$(ASM_OBJECTS) \
	$(ASM_OBJECTS:%.o=%.lst)

tools.mk

# cc65 utilities used in this example
CA65_BINARY=ca65
CC65_BINARY=cc65
LD65_BINARY=ld65
AR65_BINARY=ar65

VASM_BINARY=vasm6502_oldstyle

CPU_FLAG=--cpu 65C02
ARCH_FLAG=-t none

CC65_FLAGS=$(CPU_FLAG) $(ARCH_FLAG) $(EXTRA_FLAGS) -O
CA65_FLAGS=$(CPU_FLAG) $(EXTRA_FLAGS)
LD65_FLAGS=
AR65_FLAGS=r

VASM_FLAGS=-Fbin -dotdir

# Hexdump is used for "testing" the ROM
HEXDUMP_BINARY=hexdump
HEXDUMP_FLAGS=-C

# Checksum generator
MD5_BINARY=md5sum

# Standard utilities (rm/mkdir)
RM_BINARY=rm
RM_FLAGS=-f
MKDIR_BINARY=mkdir
MKDIR_FLAGS=-p
CP_BINARY=cp
CP_FLAGS=-f

project makefile

CONF_DIR=/home/gm4slv/6502/ca65src

ROM_NAME=monitor_dev

ASM_SOURCES=monitor_dev.s

FIRMWARE_CFG=$(CONF_DIR)/firmware.cfg

include $(CONF_DIR)/cc65.rules.mk

A typical project

monitor_dev.s setup

Put the asm source for the project in a folder (/home/gm4slv/6502/ca65src/src/monitor/monitor_dev.s)
Put the makefile in the same folder
put any source files to be included in the assembly process in the includes folder
- /home/gm4slv/6502/ca65src/src/includes/rtc.inc
- /home/gm4slv/6502/ca65src/src/includes/ioports.inc
make a build main folder /home/gm4slv/6502/ca65src/build/

The general tree:

/home/gm4slv/6502/ca65src/ = base folder for ca65 projects aka $CA65SRC

config files : firmware.cfg, cc65.rules.mk, tools.mk are in $(CA65SRC)
sources directory : src is in $(CA65SRC) → $(CA65SRC)/src
inside sources directory are build, includes and the individual project source directories. $(CA65SRC)/src/build/, $(CA65SRC)/src/includes/ and (eg) $(CA65SRC)/src/monitor/
inside each project source directory are the asm source file eg monitor_dev.s and a specific makefile

To include sources from the includes directory first define the variables, then the includes :

Variables

define zeropage variables:

.zeropage
 
DUMP_POINTER:     .res 2
FLAGS:            .res 1
TOGGLE_TIME:      .res 1
CLOCK_LAST:       .res 1
MESSAGE_POINTER:  .res 2
TICKS:            .res 4
CENTISEC:         .res 1
HUNDRED_HRS:      .res 1
TEN_HRS:          .res 1
HRS:              .res 1
TEN_MINUTES:      .res 1
MINUTES:          .res 1
TEN_SECONDS:      .res 1
SECONDS:          .res 1
MEM_POINTER:      .res 2

and define the other .bss variables:

.bss
 
INKEY:            .res 1
ASCII:            .res 4
BYTE:             .res 2
TENS:             .res 1
HUNDREDS:         .res 1
HEX:              .res 2
HEXB:             .res 2
TEMP:             .res 1
TEMP2:            .res 1

Then the includes

  .include "../includes/ioports.inc"
  .include "../includes/lcd.inc"
  .include "../includes/getkey.inc"
  .include "../includes/functions.inc"
  .include "../includes/rtc.inc"

make sure the include files have appropriate .code directive to put it in the right place when its all assembled together:

e.g. in functions.inc:

 .code
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;          convert a binary number from Accumulator, in range 00000000 -> 11111111 ($00 to $FF)
;;          to its HEX number encode as ASCII -  using a simple lookup table and print it on LCD
;;
bintohex:
  pha
  lsr
  lsr
  lsr
  lsr
  tax
  lda hexascii,x
  jsr print_char
  pla
  and #$0f
  tax
  lda hexascii,x
  jsr print_char
  rts
 
hexascii: .byte "0123456789ABCDEF"

monitor_dev.s source code

monitor_dev.s

 
.localchar '@'
 
;.SEGMENT "ZEROPAGE"
.zeropage
 
DUMP_POINTER:     .res 2
FLAGS:            .res 1
TOGGLE_TIME:      .res 1
CLOCK_LAST:       .res 1
MESSAGE_POINTER:  .res 2
TICKS:            .res 4
CENTISEC:         .res 1
HUNDRED_HRS:      .res 1
TEN_HRS:          .res 1
HRS:              .res 1
TEN_MINUTES:      .res 1
MINUTES:          .res 1
TEN_SECONDS:      .res 1
SECONDS:          .res 1
MEM_POINTER:      .res 2
 
 
;.SEGMENT "BSS"
.bss
 
INKEY:            .res 1
ASCII:            .res 4
BYTE:             .res 2
TENS:             .res 1
HUNDREDS:         .res 1
HEX:              .res 2
HEXB:             .res 2
TEMP:             .res 1
TEMP2:            .res 1
 
.include "../includes/ioports.inc"
.include "../includes/lcd.inc"
.include "../includes/getkey.inc"
.include "../includes/functions.inc"
.include "../includes/rtc.inc"
 
 
.code
 
 
reset:
  ldx #$ff
  txs
 
  cli      ; interrupts ON
 
  jsr via_1_init ; set-up VIA_1 for LCD/Keypad 
  jsr lcd_init ; set-up 4-bit mode 
  jsr lcd_start ; set-up various features of lcd 
 
init_variables:
  stz TICKS
  stz TICKS + 1
  stz TICKS + 2
  stz TICKS + 3
  stz DUMP_POINTER
  stz DUMP_POINTER + 1
  stz MESSAGE_POINTER
  stz MESSAGE_POINTER + 1
  stz TOGGLE_TIME
  stz CLOCK_LAST
  stz CENTISEC
  stz FLAGS
  stz SECONDS
  stz TEN_SECONDS
  stz MINUTES
  stz HRS
  stz TEN_HRS
  stz TEN_MINUTES
  stz HUNDRED_HRS
  stz TEMP
  stz TEMP2
  stz TENS  
  stz MEM_POINTER
  stz MEM_POINTER + 1
 
 
 
;; test then clear RAM between 
;; $0200 - $3FFF - avoids the ZP and STACK areas
 
ram_clear:
  lda #$02            ; start at $0200
  sta MEM_POINTER + 1
  ldy #$00
loop_ram:
  lda #$AA
  sta (MEM_POINTER),y
  lda #$FF
  lda (MEM_POINTER),y
  cmp #$AA
  bne mem_fail_1
  lda #$55
  sta (MEM_POINTER),y
  lda #$FF
  lda (MEM_POINTER),y
  cmp #$55
  bne mem_fail_2
  lda #$00
  sta (MEM_POINTER),y
  iny
  beq next_page
  jmp loop_ram
next_page:
  lda MEM_POINTER + 1
  inc
  cmp #$40
  beq done_ram
  sta MEM_POINTER + 1
  jmp loop_ram
 
 
done_ram:
 
  lda #<mem_pass_msg
  sta MESSAGE_POINTER
  lda #>mem_pass_msg
  sta MESSAGE_POINTER + 1
  jsr print 
  smb5 FLAGS
  jmp loop
 
mem_fail_1:
  lda #<mem_fail_msg_1
  sta MESSAGE_POINTER
  lda #>mem_fail_msg_1
  sta MESSAGE_POINTER + 1
  jsr print
  jmp loop
 
mem_fail_2:
  lda #<mem_fail_msg_2
  sta MESSAGE_POINTER
  lda #>mem_fail_msg_2
  sta MESSAGE_POINTER + 1
  jsr print
  jmp loop
 
 
 
; go straight to MONITOR at startup
;  lda #<splash
;  sta MESSAGE_POINTER
;  lda #>splash
;  sta MESSAGE_POINTER + 1
;  jsr new_address
 
; main loop
loop:
  wai
  jsr check_flags
  jmp loop
 
 
;;;;;;;;;;;;; FUNCTIONS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;
 
check_flags:
  bbs0 FLAGS, update_block_address
  bbs5 FLAGS, clock_time
  ; check other flags... other actions....
  rts
 
update_block_address:
  sec
  lda TICKS
  sbc TOGGLE_TIME
  cmp #$32
  bcc exit_update_block
  jsr block_address
  lda TICKS
  sta TOGGLE_TIME
 
exit_update_block:
  rts
 
 
clock_time:
 
  sec
  lda TICKS
  sbc CLOCK_LAST
  cmp #$32
  bcc exit_clock
 
  jsr lcd_cursor_off
 
  jsr lcd_home
 
  lda HUNDRED_HRS
  jsr bintoascii
  lda TEN_HRS
  jsr bintoascii
  lda HRS
  jsr bintoascii
  lda #':'
  jsr print_char
  lda TEN_MINUTES
  jsr bintoascii
  lda MINUTES
  jsr bintoascii
  lda #':'
  jsr print_char
  lda TEN_SECONDS
  jsr bintoascii
  lda SECONDS
  jsr bintoascii
  lda #' '
  jsr print_char
  lda TICKS
  sta CLOCK_LAST
exit_clock:
  rts
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;      update screen when new memory location is selected
;;
;;
new_address:
 
  jsr lcd_clear
 
  jsr lcd_cursor_on
 
 
print_address:
  lda #'$'
  jsr print_char
  lda DUMP_POINTER + 1
  jsr bintohex
  lda DUMP_POINTER
  jsr bintohex
 
  lda #' '
  jsr print_char
 
print_data:
 
  ldy #$00
 
  lda (DUMP_POINTER),y
  jsr bintohex
  lda #' '
  jsr print_char
  lda (DUMP_POINTER),y
  jsr print_char
 
message_end:
  jsr print   ; add second line (cursor) after re-writing the top line
  rts
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; display 8 bytes of data for a "block" of memory
;;
;;
block_address:
 
  jsr lcd_clear
 
  ldy #$00
 
print_block_address:
  lda #'$'
  jsr print_char
  lda DUMP_POINTER + 1
  jsr bintohex
  lda DUMP_POINTER
  jsr bintohex
 
  jsr lcd_line_2
 
print_block:
 
  lda (DUMP_POINTER),y
  jsr bintohex
  lda (DUMP_POINTER),y
  iny
  cpy #$08
  bne print_block
 
 
block_message_end:
  rts
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; re-draw line 2 cursor
;;
;;
print:
 
  jsr lcd_line_2
 
  ldy #0
line1:
  lda (MESSAGE_POINTER),y
  beq end_print
  jsr print_char
  iny
  jmp line1
 
end_print:
 
  rts
 
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;      Monitor function - decrement the selected address 
;;
;;
decrement_address:
 
  sec
  lda DUMP_POINTER
  sbc #$01
  sta DUMP_POINTER
  sta BYTE
  lda DUMP_POINTER + 1
  sbc #$00
  sta DUMP_POINTER + 1
  sta BYTE + 1
dec_ok:
  rts
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;      Monitor function - increment the selected address 
;;
;;
 
increment_address:
 
  clc
  lda DUMP_POINTER
  adc #$01
  sta DUMP_POINTER
  sta BYTE
  bcc inc_ok
  inc DUMP_POINTER + 1
  lda DUMP_POINTER + 1
  sta BYTE + 1
inc_ok:
  rts
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;      Monitor function - increment the selected block of  addresses by 8 
;;
;;
 
increment_block:
  clc
  lda DUMP_POINTER
  adc #$08
  sta DUMP_POINTER
  sta BYTE
  lda DUMP_POINTER + 1
  adc #$00
  sta DUMP_POINTER + 1
  sta BYTE + 1
  rts
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;      Monitor function - decrement the selected block of  addresses by 8 
;;
;;
 
decrement_block:
 
  sec
  lda DUMP_POINTER
  sbc #$08
  sta DUMP_POINTER
  sta BYTE
  lda DUMP_POINTER + 1
  sbc #$00
  sta DUMP_POINTER + 1
  sta BYTE + 1
  rts
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;          use last 4 entered ASCII characters from the keypad and convert 
;;          them to TWO 8-bit binary bytes in RAM
;;
;;
ascii_byte:
 
  lda ASCII + 1
 
  jsr ascii_bin
  clc
  asl
  asl
  asl
  asl
  sta BYTE
 
  lda ASCII
 
  jsr ascii_bin
  ora BYTE
  sta BYTE
 
  lda ASCII + 3
  jsr ascii_bin
  clc
  asl
  asl
  asl
  asl
  sta BYTE + 1
 
  lda ASCII + 2
 
  jsr ascii_bin
  ora BYTE + 1
  sta BYTE + 1
  rts
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;    toggle the display/update of Clock on each appropriate keypress
;;
show_clock:
 
  bbs5 FLAGS, reset_bit5
  smb5 FLAGS
  jmp exit_show_clock
 
reset_bit5:
 
  rmb5 FLAGS
 
exit_show_clock:
 
  rts
  ;jmp debounce
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;    toggle the automatic update view of the "8-byte memory block"
;;
show_block:
 
  bbs0 FLAGS, reset_bit0
  smb0 FLAGS
  jmp exit_show_block
 
reset_bit0:
 
  rmb0 FLAGS
 
exit_show_block:
 
  rts
  ;jmp debounce
 
;debounce:
;  ldx #$ff
;  ldy #$ff
;delay:
;  nop
;  dex
;  bne delay
;  dey
;  bne delay
;  rts  
 
 
;;;;;;;;;;;;;;;;;; INTERRUPT HANDLERS ;;;;;;;;;;;;;;;;;;;;
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;      CB1 : reset & restart timer
;;
 
cb1_handler:
  stz HUNDRED_HRS
  stz TEN_HRS
  stz TEN_MINUTES
  stz TEN_SECONDS
  stz HRS
  stz MINUTES
  stz SECONDS
 
  smb5 FLAGS
 
  rts
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;     CB2 : lap-time pause timer
;;
 
cb2_handler:
  jsr show_clock
  rts
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;                    MONITOR / KEYPAD 
;;
;;
 
keypad_handler:
 
  jsr get_key     ; READs from PORTA which also re-sets VIA's Interrupt flag
  sta INKEY       ; put the ASCII value of input into RAM ( $00 ) 
 
  lda PORTB_1       ; check for SHIFT/INSTRUCTION button
  and #%10000000
  beq check_keypress ; done this way to get around the limit in size of branch jumps....
  jmp handle_new_char
 
check_keypress:
  lda INKEY       
 
; choose action of "SHIFTed" key-press
check_a:
  cmp #'A'
  ; move up one memory address and display contents
  bne check_b     
  jsr increment_address
  jsr new_address
  jmp exit_key_irq
 
check_b:
  cmp #'B'
  ; move down one memory address and display contents
  bne check_c
  jsr decrement_address
  jsr new_address
  jmp exit_key_irq
 
check_c:
  cmp #'C'
  ; return to MONITOR
  bne check_d
  rmb5 FLAGS
  jsr lcd_clear
  lda #<splash
  sta MESSAGE_POINTER
  lda #>splash
  sta MESSAGE_POINTER + 1
 
  jsr new_address
  jmp exit_key_irq
 
check_d:
  cmp #'D'
  ; move monitor to entered 4-digit memory address
  bne check_e
  lda BYTE
  sta DUMP_POINTER
  lda BYTE + 1
  sta DUMP_POINTER + 1
  jsr new_address
  jsr print
  jmp exit_key_irq
 
check_e:
  cmp #'E'
  ; insert (POKE) byte of data in to current memory address, then increment to next address
  bne check_f
  lda BYTE
  ldy #$00
  sta (DUMP_POINTER),y
  jsr increment_address
  jsr new_address
  jsr print
  jmp exit_key_irq
 
check_f:
  cmp #'F'
  ; show 8-byte wide block of memory
  bne check_1
  ldy #$00
  lda BYTE
  sta DUMP_POINTER
  lda BYTE + 1
  sta DUMP_POINTER + 1
  jsr block_address
  jmp exit_key_irq
 
check_1:
  cmp #'1'
  ; show/auto-update clock
  bne check_3
  jsr lcd_clear
  lda #<emt
  sta MESSAGE_POINTER
  lda #>emt
  sta MESSAGE_POINTER + 1
  jsr print
  smb5 FLAGS
 
  ;jsr show_clock
  jmp exit_key_irq
 
check_3:
  cmp #'3'
  bne check_6
  ldy #$00
  jsr increment_block
  jsr block_address
  jmp exit_key_irq
 
check_6:
  cmp #'6'
  bne check_9
  ldy #$00
  jsr decrement_block
  jsr block_address
  jmp exit_key_irq
 
check_9:
  cmp #'9'
  bne check_4
  jsr show_block
  jmp exit_key_irq
 
check_4:
  cmp #'4'
  bne check_5
  lda BYTE
  sta HEXB
  lda BYTE + 1
  sta HEXB + 1
  jsr byte_to_hex
  jmp exit_key_irq
 
check_5:
  cmp #'5'
  bne exit_key_irq
  jsr $3F00
  jmp exit_key_irq
 
 
handle_new_char:
  lda ASCII + 2
  sta ASCII + 3
  lda ASCII + 1
  sta ASCII + 2
  lda ASCII
  sta ASCII + 1
  lda INKEY       ; get the new ASCII keypress value and... 
  sta ASCII
  jsr print_char  ; and print it on LCD
 
  jsr ascii_byte  ; convert the rolling 4-byte ASCII character data into two binary bytes
 
exit_key_irq:
 
 
  jsr scan  ; re-enable keypad
 
  rts
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
nmi:
  rti
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;    interrupt is triggered by HIGH edge on VIA CA1 pin
;;     PORTA low nibble (keypad columns) inputs are diode ORed to CA1
;;
 
irq:
; put registers on the stack while handling the IRQ
  pha
  phx
  phy
 
;  find responsible hardware
 
;  Is it VIA_1?
 
  lda IFR_1   ; if IFR_1 has Bit7 set (ie sign=NEGATIVE) then it IS the source of the interrupt
  bpl next_device ; if it's not set (ie sign=POSITIVE) then branch to test the next possible device
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; IFR Flags
;; B7  B6  B5  B4  B3  B2  B1  B0
;; IRQ TI1 TI2 CB1 CB2 SR CA1 CA2
;;
;; Interrupt source is found by sequentially shifting IFR bit left to put bit-of-interest into the CARRY place
;; and then branching based on whether CARRY is SET or not
;;
;; Only add tests for IRQ sources in use, and adjust the ASLs in each test as necessary
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
test_timer1:
  asl           ; shift IFR left twice puts the TI1 bit into CARRY....
  asl
  bcc test_cb1  ; carry clear = next test
  bit T1CL_1      ; clear not clear = handle the TIMER interrupt
  jsr rtc
  jmp exit_irq
 
test_cb1:
  asl
  asl
  bcc test_cb2
  bit PORTB_1
  jsr cb1_handler
  jmp exit_irq
 
test_cb2:
  asl
  bcc test_ca1
  bit PORTB_1
  jsr cb2_handler
  jmp exit_irq
 
test_ca1:
  asl           ; shift CA1 bit into the CARRY bit & test
  asl
  bcc exit_irq        ; carry clear = leave
  jsr keypad_handler  ; carry not clear = handle the CA1 interrupt (keypad)
  jmp exit_irq
 
 
next_device:
 
exit_irq:
  ply
  plx
  pla
 
 
  rti
 
emt: .asciiz "hhh mm ss  MET"
splash: .asciiz "cmon> "
error_message: .asciiz "Not Decimal"
mem_pass_msg: .asciiz "RAM Test Pass"
mem_fail_msg_1: .asciiz "RAM Test 1 Fail"
mem_fail_msg_2: .asciiz "RAM Test 2 Fail"
 
; Reset/IRQ vectors
 
.segment "VECTORS"
 
 
  .word nmi
  .word reset
  .word irq

ioports.inc

  .code
 
; VIA_1 Port addresses
VIA_1     = $6000
PORTB_1   = VIA_1
PORTA_1   = VIA_1 + 1
DDRB_1    = VIA_1 + 2
DDRA_1    = VIA_1 + 3
T1CL_1    = VIA_1 + 4
T1CH_1    = VIA_1 + 5
T1LL_1    = VIA_1 + 6
T1LH_1    = VIA_1 + 7
T2CL_1    = VIA_1 + 8
T2CH_1    = VIA_1 + 9
SR_1      = VIA_1 + 10
ACR_1     = VIA_1 + 11
PCR_1     = VIA_1 + 12
IFR_1     = VIA_1 + 13
IER_1     = VIA_1 + 14
PORTA_NO_HS_1 = VIA_1 + 15
 
; VIA_2 Port addresses
VIA_2     = $5000
PORTB_2   = VIA_2
PORTA_2   = VIA_2 + 1
DDRB_2    = VIA_2 + 2
DDRA_2    = VIA_2 + 3
T1CL_2    = VIA_2 + 4
T1CH_2    = VIA_2 + 5
T1LL_2    = VIA_2 + 6
T1LH_2    = VIA_2 + 7
T2CL_2    = VIA_2 + 8
T2CH_2    = VIA_2 + 9
SR_2      = VIA_2 + 10
ACR_2     = VIA_2 + 11
PCR_2     = VIA_2 + 12
IFR_2     = VIA_2 + 13
IER_2     = VIA_2 + 14
PORTA_NO_HS_2 = VIA_2 + 15
 
; VIA_3 Port addresses
VIA_3     = $4800
PORTB_3   = VIA_3
PORTA_3   = VIA_3 + 1
DDRB_3    = VIA_3 + 2
DDRA_3    = VIA_3 + 3
T1CL_3    = VIA_3 + 4
T1CH_3    = VIA_3 + 5
T1LL_3    = VIA_3 + 6
T1LH_3    = VIA_3 + 7
T2CL_3    = VIA_3 + 8
T2CH_3    = VIA_3 + 9
SR_3      = VIA_3 + 10
ACR_3     = VIA_3 + 11
PCR_3     = VIA_3 + 12
IFR_3     = VIA_3 + 13
IER_3     = VIA_3 + 14
PORTA_NO_HS_3 = VIA_3 + 15
 
; ACIA_1 Port Addresses
ACIA_1    = $4400
S_TXRX_1  = ACIA_1      ; TXD / RXD
S_STA_1   = ACIA_1 + 1  ; Status
S_COM_1   = ACIA_1 + 2  ; Command
S_CON_1   = ACIA_1 + 3  ; Control
 
 
via_1_init:
 
  lda #%01000000
  sta ACR_1
  lda #$0E
  sta T1CL_1
  lda #$27
  sta T1CH_1
 
  lda #%11011010  ; T1, CA1 active
  sta IER_1
 
  lda #$01  ;  CA1 active high-transition 
  sta PCR_1
 
  lda #%01111111 ; Set all pins on port B to output except BIT 7 which is used for "SHIFT/INSTRUCTION"  button
  sta DDRB_1
  lda #%11110000 ; Set low-nibble pins on port A to input and high-nibble pins to output, for keypad
  sta DDRA_1
 
  rts

lcd.inc

 
 
  .code
 
; LCD Command masks
E  = %01000000
RW = %00100000
RS = %00010000
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;
;;                              LCD Functions 
;;
;;
;;
 
lcd_start:
  lda #%00101000 ; Set 4-bit mode; 2-line display; 5x8 font
  jsr lcd_instruction
  jsr lcd_entry_mode
  jsr lcd_cursor_off
  jsr lcd_clear
  rts
 
lcd_entry_mode:
  lda #%00000110 ; Increment and shift cursor; don't shift display
  jsr lcd_instruction
  rts
 
lcd_home:
  lda #%00000010 ; cursor HOME
  jsr lcd_instruction
  rts
 
lcd_clear:
  lda #%00000001 ; Clear display
  jsr lcd_instruction
  rts
 
lcd_cursor_off:
  lda #%00001100 ; Display on; cursor off; blink off
  jsr lcd_instruction
  rts
 
lcd_cursor_on:
  lda #%00001111 ; Display on; cursor on; blink on
  jsr lcd_instruction
  rts
 
lcd_line_2:
  lda #%10101001
  jsr lcd_instruction
  rts
 
lcd_wait:
  pha
  lda #%01110000  ; LCD data is input (don't change MSB BIT7, it has to stay ZERO for SHIFT Button input)
  sta DDRB_1
lcdbusy:
  lda #RW
  sta PORTB_1
  lda #(RW | E)
  sta PORTB_1
  lda PORTB_1     ; Read high nibble
  pha             ; and put on stack since it has the busy flag
  lda #RW
  sta PORTB_1
  lda #(RW | E)
  sta PORTB_1
  lda PORTB_1       ; Read low nibble
  pla             ; Get high nibble off stack
  and #%00001000
  bne lcdbusy
 
  lda #RW
  sta PORTB_1
  lda #%01111111  ; LCD data is output (don't change MSB BIT7, it has to stay ZERO for SHIFT Buttion input)
  sta DDRB_1
  pla
  rts
 
lcd_init:
  lda #%00000010 ; Set 4-bit mode : DO ONCE AT POWER UP
  sta PORTB_1
  ora #E
  sta PORTB_1
  and #%00001111
  sta PORTB_1
  rts
 
lcd_instruction:
  jsr lcd_wait
  pha
  lsr
  lsr
  lsr
  lsr            ; Send high 4 bits
  sta PORTB_1
  ora #E         ; Set E bit to send instruction
  sta PORTB_1
  eor #E         ; Clear E bit
  sta PORTB_1
  pla
  and #%00001111 ; Send low 4 bits
  sta PORTB_1
  ora #E         ; Set E bit to send instruction
  sta PORTB_1
  eor #E         ; Clear E bit
  sta PORTB_1
  rts
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;   
;;        PRINT Characters on LCD - an ASCII value in Accumulator 
;;        is printed on the display
;;
 
print_char:
  jsr lcd_wait
  pha
  lsr
  lsr
  lsr
  lsr             ; Send high 4 bits
  ora #RS         ; Set RS
  sta PORTB_1
  ora #E          ; Set E bit to send instruction
  sta PORTB_1
  eor #E          ; Clear E bit
  sta PORTB_1
  pla
  and #%00001111  ; Send low 4 bits
  ora #RS         ; Set RS
  sta PORTB_1
  ora #E          ; Set E bit to send instruction
  sta PORTB_1
  eor #E          ; Clear E bit
  sta PORTB_1
  rts

getkey.inc

 
  .code
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;
;;      READ THE 4x4 keypad using  VIA_1 PORTA 
;;
;;      Accumulator holds the ASCII value of the pressed key when it returns
;;
 
get_key:
readKeypad:
  ldx #$04        ; Row 4 - counting down
  ldy #%10000000  ;
ScanRow:
  sty PORTA_1
  lda PORTA_1
  and #%00001111  ; mask off keypad input - only low 4 (keypad column) bits are read
  cmp #$00
  bne Row_Found   ; non-zero means a row output has been connected via a switch to a column input
  dex             ; zero means it hasn't been found, so check next row down
  tya
  lsr
  tay
  cmp #%00001000
  bne ScanRow
  lda #$ff
  rts
Row_Found:
  stx TEMP ; store row
  ldy #$ff
FindCol:
  iny
  lsr
  bcc FindCol
  tya
  asl
  asl  ; col * 4
  clc
  adc TEMP ; add row 
  tax
  lda keypad_array,x
  rts
 
 
keypad_array: .byte "?DCBAF9630852E741"
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;  set ROW keypad outputs high as a source for triggering interrupt when a key is pressed
;;
;;
scan:
  ldy #%11110000
  sty PORTA_1
  rts

functions.inc

 
;.zeropage
;MESSAGE_POINTER = $20
;
;  .org $8000
  .code
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;          convert a binary number from Accumulator, in range 00000000 -> 11111111 ($00 to $FF)
;;          to its HEX number encode as ASCII -  using a simple lookup table and print it on LCD
;;
bintohex:
  pha
  lsr
  lsr
  lsr
  lsr
  tax
  lda hexascii,x
  jsr print_char
  pla
  and #$0f
  tax
  lda hexascii,x
  jsr print_char
  rts
 
hexascii: .byte "0123456789ABCDEF"
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;    convert a binary (hex) value in Accumulator into
;;    its ASCII equivalent character in decimal 0-99 and print it
;;    this converts hex/binary numbers from the RTC into human readable
;;    decimal for display on clock
 
 
bintoascii:
 
  cmp #10
  bmi single_figure
  asl
  tax
  lda binascii,x
  jsr print_char
 
  inx
 
  lda binascii,x
  jsr print_char
  rts
 
single_figure:
  asl
  tax
  inx
  lda binascii,x
  jsr print_char
  rts
 
 
binascii: .byte "00010203040506070809"
          .byte "10111213141516171819"
          .byte "20212223242526272829"
          .byte "30313233343536373839"
          .byte "40414243444546474849"
          .byte "50515253545556575859"
          .byte "60616263646566676869"
          .byte "70717273747576777879"
          .byte "80818283848586878889"
          .byte "90919293949596979899"
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;      Convert a decimal number entered at keypad into its
;;      HEX equivalent and display
;;
 
byte_to_hex:
 
  jsr lcd_clear
  lda HEXB + 1
  and #$0f
  jsr bintohex
  lda HEXB
  jsr bintohex
  lda #'d'
  jsr print_char
  lda #'='
  jsr print_char
  lda #'$'
  jsr print_char
 
  lda HEXB ; lo byte
  pha
  lsr
  lsr
  lsr
  lsr
  cmp #10
  bpl error
  jsr mult10
  sta TENS
  pla
  and #%00001111 ; UNITS
  cmp #10
  bpl print_error
;  jsr mult10
  clc
  adc TENS
  sta HEX
 
  lda HEXB + 1 ; hi byte
  and #%00001111
  cmp #10
  bpl print_error
  jsr mult10
  jsr mult10 ; hundreds
  adc HEX
 
  jsr bintohex
  jmp exit_byte_to_hex
 
error:
  pla
print_error:
  lda #<error_message
  sta MESSAGE_POINTER
  lda #>error_message
  sta MESSAGE_POINTER + 1
  jsr print
  ;jsr lcd_cursor_off
  rts
 
exit_byte_to_hex:
  jsr lcd_line_2
 
  rts
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;  (A * 8) + (A * 2) = A * 10 
 
mult10:
  pha
  asl
  asl
  asl
  sta TEMP2 ; A*8
  pla
  asl      ; A*2
  adc TEMP2 ; A*10
  rts
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Convert the encoded ASCII character representing a hex digit to its actual binary value.
;;
;; e.g. Letter "A" in ASCII is $41 (0100001) but its "numerical" value as a hex digit is 
;; 10 ($0A = 10d = %00001010). 
;; 
;; We convert "A" in ASCII ($41) to a byte of numerical value 10 by subtracting $37
;; $41 - $37 = $0A (in decimal 65 - 55 = 10) and the result is a byte 00001010
;; The same is done for all characters representing upper case letters.
;;
;; Numbers are handled differently according to their place on the ASCII table.
;;
;; The ASCII representation of "9" is $39 (00111001) and to get a byte with a value of 9 we can simply
;; AND it with a mask of 00001111 to save only the lower 4 bits.
;;
 
ascii_bin:
  clc
  cmp #$41
  bmi ascii_bin_num   ; a CMP with $41, from a number character ($30 - $39), will set the negative flag
                      ; and the conversion is done by ANDing with $0F
 
ascii_bin_letter:    ; otherwise treat as a letter (A -> F) and the conversion is done by
  clc                ; subtracting $37
  sec
  sbc #$37
  jmp end_ascii_bin
 
ascii_bin_num:
  and #%00001111
 
end_ascii_bin:      ; Accumulator holds the numerical version of the ASCII character supplied
  rts

rtc.inc

 
 
 
 
  .code
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;                          RTC / Jiffy Tick
;;
 
 
 
rtc:
 
 
;;  RTC stores ticks at 10ms intervals into a 4-byte (32 bit) value
;;
;;  as each byte rolls over the next one is incremented
;;  on a tick that doesn't roll over the TIME OF DAY 
;;  is updated
 
  inc TICKS
  bne inc_MET
  inc TICKS + 1
  bne inc_MET
  inc TICKS + 2
  bne inc_MET
  inc TICKS + 3
 
;;
;;  Every time it's called we increment the "hundredths of a second" byte
;;
;;  When there's been 100 x 10ms (i.e. 1 second) we increment the seconds
;;
;;  When SECONDS reaches 60 we increment MINUTES and reset SECONDS to zero...
;;  etc... for HOURS, DAYS etc.
;;
;;  days/months years are handled too - although probably moot
;;
;;  this routine comes from http://wilsonminesco.com/6502interrupts/#2.1
;;
inc_MET:
  inc CENTISEC
  lda CENTISEC
  cmp #100
  bmi end_MET
  stz CENTISEC
 
  inc SECONDS
  lda SECONDS
  cmp #10
  bmi end_MET
  stz SECONDS
  inc TEN_SECONDS
 
  lda TEN_SECONDS
  cmp #6
  bmi end_MET
  stz TEN_SECONDS
 
  inc MINUTES
  lda MINUTES
  cmp #10
  bmi end_MET
  stz MINUTES
 
  inc TEN_MINUTES
  lda TEN_MINUTES
  cmp #6
  bmi end_MET
  stz TEN_MINUTES
 
  inc HRS
  lda HRS
  cmp #10
  bmi end_MET
  stz HRS
 
  inc TEN_HRS
  lda TEN_HRS
  cmp #10
  bmi end_MET
  stz TEN_HRS
 
  inc HUNDRED_HRS
 
end_MET:
  rts

— John Pumford-Green 05/09/22 14:23

Further Information

Datasheets

anonymous@undisclosed.example.com (Anonymous) — Tue, 30 Dec 2025 10:10:35 +0000

←6502 Project

Datasheets

Datasheets for parts used in my 6502 project

CPU

WD 65C02

EEPROM

28C256 EEPROM

RAM

62256 RAM

LCD

Generic LCD

VIA

WDC 65C22 VIA

ACIA

Rockwell 65C51

WDC 65C51

RTC

Maxim DS1306

Various support chips

74HC00 Quad NAND

NE555

MAX232 TTL-RS232

74LS21 dual 4-input AND

— John Pumford-Green 24/09/22 13:25

Further Information

6502

Goals : 6502

anonymous@undisclosed.example.com (Anonymous) — Sun, 02 Mar 2025 11:21:25 +0000

←6502 Project

Goals : 6502

What do I want to achieve

Phase One

~~Follow Ben Eater's 6502 Tutorials and become familiar with the mechanism of programming the 6502~~
~~Adapt some of the code to gain experience at modifying 6502 assembly code~~
make some mini code projects to get experience of handling input, output and interrupts

Phase Two

~~add key-pad for simple user input~~
~~write simple ''monitor'' firmware to gain experience with user i/o etc.~~
add serial port hardware and enough software to send/receive RS232 to/from a terminal
write routines for LCD display of RS232 data received
investigate using additional VIA port(s) to interact with external hardware
~~refine hardware design and move OFF breadboard onto more permanent hardware (vero/perf board etc)~~
investigate parsing and reacting to input via RS232, beyond simply receive/transmit and display - interact with the machine!

Phase Three

specific projects - e.g. DSC, Selcall etc
keep an open mind and keep learning new techniques….
- this phase will largely depend on what is learned earlier….

— John Pumford-Green 15/08/22 09:23

Further Information

6502

Links

anonymous@undisclosed.example.com (Anonymous) — Tue, 30 Dec 2025 09:55:07 +0000

←6502 Project

Monitor

anonymous@undisclosed.example.com (Anonymous) — Sun, 07 Apr 2024 23:13:33 +0000

←6502 Project

Monitor

My first attempts at a Monitor program

Features

RAM is tested at power-up- writing and checking with 2 different bit patterns, then zeroing RAM if successful (avoiding ZeroPage and Stack areas)
display a “Mission Elapsed Time” counter and reset to zero with a button press
step forward and backward through memory locations
display hex data and its ASCII equivalent for each memory location (PEEK)
enter a 2-digit hex value and write it into the currently selected memory location (POKE)
enter a 4-digit hex value and move to that chosen memory address
display an 8-byte block of memory data on one line, starting at the currently selected address
display an 8-byte block of memory data and have it auto-refresh at 1 second intervals
move to a pre-determined address ($3F00) in memory and begin executing code from that point
- this allows machine code to be entered directly from $3F00 onwards and then executed. It's cumbersome, but makes the machine programmable!

Data/addresses are entered on the keypad. Commands are entered by pressing the “SHIFT/INSTRUCT” button at the same time as one of the pre-set instructions.

`Shift`+`1` `MET CLOCK`	2	`Shift`+`3` `BLOCK UP`	`Shift`+`A` `UP`
`Shift`+`4` `dec→hex`	`Shift`+`5` `GO`	`Shift`+`6` `BLOCK DOWN`	`Shift`+`B` `DOWN`
7	8	`Shift`+`9` `auto-update Block view`	`Shift`+`C` `CLS`
`Shift`+`E` `POKE`	0	`Shift`+`F` `BLOCK`	`Shift`+`D` `PEEK`

Shift+1 = MET Clock
Shift+2
Shift+3 = Display the next 8-byte block up - aka “page Up”
Shift+A = Memory selected = UP one
Shift+4 = Convert an entered decimal number to its HEX equivalent
Shift+5 = GO! (jsr $3F00)
Shift+6 = Display the next 8-byte block down - aka “page Down”
Shift+B = Memory selected = DOWN one
Shift+7
Shift+8
Shift+9 = Update 8-byte block view at 1-second intervals
Shift+C = Clear Screen
Shift+E = Enter data byte into selected memory address - aka POKE
Shift+0
Shift+F = Display an 8-byte block of data, starting from current memory address
Shift+D = move to the new memory location provided in last 4 digits entered

monitor_dev.s

 
.localchar '@'
 
;.SEGMENT "ZEROPAGE"
.zeropage
 
DUMP_POINTER:     .res 2
FLAGS:            .res 1
TOGGLE_TIME:      .res 1
CLOCK_LAST:       .res 1
MESSAGE_POINTER:  .res 2
TICKS:            .res 4
CENTISEC:         .res 1
HUNDRED_HRS:      .res 1
TEN_HRS:          .res 1
HRS:              .res 1
TEN_MINUTES:      .res 1
MINUTES:          .res 1
TEN_SECONDS:      .res 1
SECONDS:          .res 1
MEM_POINTER:      .res 2
 
 
;.SEGMENT "BSS"
.bss
 
INKEY:            .res 1
ASCII:            .res 4
BYTE:             .res 2
TENS:             .res 1
HUNDREDS:         .res 1
HEX:              .res 2
HEXB:             .res 2
TEMP:             .res 1
TEMP2:            .res 1
 
.include "../includes/ioports.inc"
.include "../includes/lcd.inc"
.include "../includes/getkey.inc"
.include "../includes/functions.inc"
.include "../includes/rtc.inc"
 
 
.code
 
 
reset:
  ldx #$ff
  txs
 
  cli      ; interrupts ON
 
  jsr via_1_init ; set-up VIA_1 for LCD/Keypad 
  jsr lcd_init ; set-up 4-bit mode 
  jsr lcd_start ; set-up various features of lcd 
 
init_variables:
  stz TICKS
  stz TICKS + 1
  stz TICKS + 2
  stz TICKS + 3
  stz DUMP_POINTER
  stz DUMP_POINTER + 1
  stz MESSAGE_POINTER
  stz MESSAGE_POINTER + 1
  stz TOGGLE_TIME
  stz CLOCK_LAST
  stz CENTISEC
  stz FLAGS
  stz SECONDS
  stz TEN_SECONDS
  stz MINUTES
  stz HRS
  stz TEN_HRS
  stz TEN_MINUTES
  stz HUNDRED_HRS
  stz TEMP
  stz TEMP2
  stz TENS  
  stz MEM_POINTER
  stz MEM_POINTER + 1
 
 
 
;; test then clear RAM between 
;; $0200 - $3FFF - avoids the ZP and STACK areas
 
ram_clear:
  lda #$02            ; start at $0200
  sta MEM_POINTER + 1
  ldy #$00
loop_ram:
  lda #$AA
  sta (MEM_POINTER),y
  lda #$FF
  lda (MEM_POINTER),y
  cmp #$AA
  bne mem_fail_1
  lda #$55
  sta (MEM_POINTER),y
  lda #$FF
  lda (MEM_POINTER),y
  cmp #$55
  bne mem_fail_2
  lda #$00
  sta (MEM_POINTER),y
  iny
  beq next_page
  jmp loop_ram
next_page:
  lda MEM_POINTER + 1
  inc
  cmp #$40
  beq done_ram
  sta MEM_POINTER + 1
  jmp loop_ram
 
 
done_ram:
 
  lda #<mem_pass_msg
  sta MESSAGE_POINTER
  lda #>mem_pass_msg
  sta MESSAGE_POINTER + 1
  jsr print 
  smb5 FLAGS
  jmp loop
 
mem_fail_1:
  lda #<mem_fail_msg_1
  sta MESSAGE_POINTER
  lda #>mem_fail_msg_1
  sta MESSAGE_POINTER + 1
  jsr print
  jmp loop
 
mem_fail_2:
  lda #<mem_fail_msg_2
  sta MESSAGE_POINTER
  lda #>mem_fail_msg_2
  sta MESSAGE_POINTER + 1
  jsr print
  jmp loop
 
 
 
; go straight to MONITOR at startup
;  lda #<splash
;  sta MESSAGE_POINTER
;  lda #>splash
;  sta MESSAGE_POINTER + 1
;  jsr new_address
 
; main loop
loop:
  wai
  jsr check_flags
  jmp loop
 
 
;;;;;;;;;;;;; FUNCTIONS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;
 
check_flags:
  bbs0 FLAGS, update_block_address
  bbs5 FLAGS, clock_time
  ; check other flags... other actions....
  rts
 
update_block_address:
  sec
  lda TICKS
  sbc TOGGLE_TIME
  cmp #$32
  bcc exit_update_block
  jsr block_address
  lda TICKS
  sta TOGGLE_TIME
 
exit_update_block:
  rts
 
 
clock_time:
 
  sec
  lda TICKS
  sbc CLOCK_LAST
  cmp #$32
  bcc exit_clock
 
  jsr lcd_cursor_off
 
  jsr lcd_home
 
  lda HUNDRED_HRS
  jsr bintoascii
  lda TEN_HRS
  jsr bintoascii
  lda HRS
  jsr bintoascii
  lda #':'
  jsr print_char
  lda TEN_MINUTES
  jsr bintoascii
  lda MINUTES
  jsr bintoascii
  lda #':'
  jsr print_char
  lda TEN_SECONDS
  jsr bintoascii
  lda SECONDS
  jsr bintoascii
  lda #' '
  jsr print_char
  lda TICKS
  sta CLOCK_LAST
exit_clock:
  rts
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;      update screen when new memory location is selected
;;
;;
new_address:
 
  jsr lcd_clear
 
  jsr lcd_cursor_on
 
 
print_address:
  lda #'$'
  jsr print_char
  lda DUMP_POINTER + 1
  jsr bintohex
  lda DUMP_POINTER
  jsr bintohex
 
  lda #' '
  jsr print_char
 
print_data:
 
  ldy #$00
 
  lda (DUMP_POINTER),y
  jsr bintohex
  lda #' '
  jsr print_char
  lda (DUMP_POINTER),y
  jsr print_char
 
message_end:
  jsr print   ; add second line (cursor) after re-writing the top line
  rts
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; display 8 bytes of data for a "block" of memory
;;
;;
block_address:
 
  jsr lcd_clear
 
  ldy #$00
 
print_block_address:
  lda #'$'
  jsr print_char
  lda DUMP_POINTER + 1
  jsr bintohex
  lda DUMP_POINTER
  jsr bintohex
 
  jsr lcd_line_2
 
print_block:
 
  lda (DUMP_POINTER),y
  jsr bintohex
  lda (DUMP_POINTER),y
  iny
  cpy #$08
  bne print_block
 
 
block_message_end:
  rts
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; re-draw line 2 cursor
;;
;;
print:
 
  jsr lcd_line_2
 
  ldy #0
line1:
  lda (MESSAGE_POINTER),y
  beq end_print
  jsr print_char
  iny
  jmp line1
 
end_print:
 
  rts
 
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;      Monitor function - decrement the selected address 
;;
;;
decrement_address:
 
  sec
  lda DUMP_POINTER
  sbc #$01
  sta DUMP_POINTER
  sta BYTE
  lda DUMP_POINTER + 1
  sbc #$00
  sta DUMP_POINTER + 1
  sta BYTE + 1
dec_ok:
  rts
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;      Monitor function - increment the selected address 
;;
;;
 
increment_address:
 
  clc
  lda DUMP_POINTER
  adc #$01
  sta DUMP_POINTER
  sta BYTE
  bcc inc_ok
  inc DUMP_POINTER + 1
  lda DUMP_POINTER + 1
  sta BYTE + 1
inc_ok:
  rts
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;      Monitor function - increment the selected block of  addresses by 8 
;;
;;
 
increment_block:
  clc
  lda DUMP_POINTER
  adc #$08
  sta DUMP_POINTER
  sta BYTE
  lda DUMP_POINTER + 1
  adc #$00
  sta DUMP_POINTER + 1
  sta BYTE + 1
  rts
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;      Monitor function - decrement the selected block of  addresses by 8 
;;
;;
 
decrement_block:
 
  sec
  lda DUMP_POINTER
  sbc #$08
  sta DUMP_POINTER
  sta BYTE
  lda DUMP_POINTER + 1
  sbc #$00
  sta DUMP_POINTER + 1
  sta BYTE + 1
  rts
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;          use last 4 entered ASCII characters from the keypad and convert 
;;          them to TWO 8-bit binary bytes in RAM
;;
;;
ascii_byte:
 
  lda ASCII + 1
 
  jsr ascii_bin
  clc
  asl
  asl
  asl
  asl
  sta BYTE
 
  lda ASCII
 
  jsr ascii_bin
  ora BYTE
  sta BYTE
 
  lda ASCII + 3
  jsr ascii_bin
  clc
  asl
  asl
  asl
  asl
  sta BYTE + 1
 
  lda ASCII + 2
 
  jsr ascii_bin
  ora BYTE + 1
  sta BYTE + 1
  rts
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;    toggle the display/update of Clock on each appropriate keypress
;;
show_clock:
 
  bbs5 FLAGS, reset_bit5
  smb5 FLAGS
  jmp exit_show_clock
 
reset_bit5:
 
  rmb5 FLAGS
 
exit_show_clock:
 
  rts
  ;jmp debounce
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;    toggle the automatic update view of the "8-byte memory block"
;;
show_block:
 
  bbs0 FLAGS, reset_bit0
  smb0 FLAGS
  jmp exit_show_block
 
reset_bit0:
 
  rmb0 FLAGS
 
exit_show_block:
 
  rts
  ;jmp debounce
 
;debounce:
;  ldx #$ff
;  ldy #$ff
;delay:
;  nop
;  dex
;  bne delay
;  dey
;  bne delay
;  rts  
 
 
;;;;;;;;;;;;;;;;;; INTERRUPT HANDLERS ;;;;;;;;;;;;;;;;;;;;
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;      CB1 : reset & restart timer
;;
 
cb1_handler:
  stz HUNDRED_HRS
  stz TEN_HRS
  stz TEN_MINUTES
  stz TEN_SECONDS
  stz HRS
  stz MINUTES
  stz SECONDS
 
  smb5 FLAGS
 
  rts
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;     CB2 : lap-time pause timer
;;
 
cb2_handler:
  jsr show_clock
  rts
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;                    MONITOR / KEYPAD 
;;
;;
 
keypad_handler:
 
  jsr get_key     ; READs from PORTA which also re-sets VIA's Interrupt flag
  sta INKEY       ; put the ASCII value of input into RAM ( $00 ) 
 
  lda PORTB_1       ; check for SHIFT/INSTRUCTION button
  and #%10000000
  beq check_keypress ; done this way to get around the limit in size of branch jumps....
  jmp handle_new_char
 
check_keypress:
  lda INKEY       
 
; choose action of "SHIFTed" key-press
check_a:
  cmp #'A'
  ; move up one memory address and display contents
  bne check_b     
  jsr increment_address
  jsr new_address
  jmp exit_key_irq
 
check_b:
  cmp #'B'
  ; move down one memory address and display contents
  bne check_c
  jsr decrement_address
  jsr new_address
  jmp exit_key_irq
 
check_c:
  cmp #'C'
  ; return to MONITOR
  bne check_d
  rmb5 FLAGS
  jsr lcd_clear
  lda #<splash
  sta MESSAGE_POINTER
  lda #>splash
  sta MESSAGE_POINTER + 1
 
  jsr new_address
  jmp exit_key_irq
 
check_d:
  cmp #'D'
  ; move monitor to entered 4-digit memory address
  bne check_e
  lda BYTE
  sta DUMP_POINTER
  lda BYTE + 1
  sta DUMP_POINTER + 1
  jsr new_address
  jsr print
  jmp exit_key_irq
 
check_e:
  cmp #'E'
  ; insert (POKE) byte of data in to current memory address, then increment to next address
  bne check_f
  lda BYTE
  ldy #$00
  sta (DUMP_POINTER),y
  jsr increment_address
  jsr new_address
  jsr print
  jmp exit_key_irq
 
check_f:
  cmp #'F'
  ; show 8-byte wide block of memory
  bne check_1
  ldy #$00
  lda BYTE
  sta DUMP_POINTER
  lda BYTE + 1
  sta DUMP_POINTER + 1
  jsr block_address
  jmp exit_key_irq
 
check_1:
  cmp #'1'
  ; show/auto-update clock
  bne check_3
  jsr lcd_clear
  lda #<emt
  sta MESSAGE_POINTER
  lda #>emt
  sta MESSAGE_POINTER + 1
  jsr print
  smb5 FLAGS
 
  ;jsr show_clock
  jmp exit_key_irq
 
check_3:
  cmp #'3'
  bne check_6
  ldy #$00
  jsr increment_block
  jsr block_address
  jmp exit_key_irq
 
check_6:
  cmp #'6'
  bne check_9
  ldy #$00
  jsr decrement_block
  jsr block_address
  jmp exit_key_irq
 
check_9:
  cmp #'9'
  bne check_4
  jsr show_block
  jmp exit_key_irq
 
check_4:
  cmp #'4'
  bne check_5
  lda BYTE
  sta HEXB
  lda BYTE + 1
  sta HEXB + 1
  jsr byte_to_hex
  jmp exit_key_irq
 
check_5:
  cmp #'5'
  bne exit_key_irq
  jsr $3F00
  jmp exit_key_irq
 
 
handle_new_char:
  lda ASCII + 2
  sta ASCII + 3
  lda ASCII + 1
  sta ASCII + 2
  lda ASCII
  sta ASCII + 1
  lda INKEY       ; get the new ASCII keypress value and... 
  sta ASCII
  jsr print_char  ; and print it on LCD
 
  jsr ascii_byte  ; convert the rolling 4-byte ASCII character data into two binary bytes
 
exit_key_irq:
 
 
  jsr scan  ; re-enable keypad
 
  rts
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
nmi:
  rti
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;    interrupt is triggered by HIGH edge on VIA CA1 pin
;;     PORTA low nibble (keypad columns) inputs are diode ORed to CA1
;;
 
irq:
; put registers on the stack while handling the IRQ
  pha
  phx
  phy
 
;  find responsible hardware
 
;  Is it VIA_1?
 
  lda IFR_1   ; if IFR_1 has Bit7 set (ie sign=NEGATIVE) then it IS the source of the interrupt
  bpl next_device ; if it's not set (ie sign=POSITIVE) then branch to test the next possible device
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; IFR Flags
;; B7  B6  B5  B4  B3  B2  B1  B0
;; IRQ TI1 TI2 CB1 CB2 SR CA1 CA2
;;
;; Interrupt source is found by sequentially shifting IFR bit left to put bit-of-interest into the CARRY place
;; and then branching based on whether CARRY is SET or not
;;
;; Only add tests for IRQ sources in use, and adjust the ASLs in each test as necessary
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
test_timer1:
  asl           ; shift IFR left twice puts the TI1 bit into CARRY....
  asl
  bcc test_cb1  ; carry clear = next test
  bit T1CL_1      ; clear not clear = handle the TIMER interrupt
  jsr rtc
  jmp exit_irq
 
test_cb1:
  asl
  asl
  bcc test_cb2
  bit PORTB_1
  jsr cb1_handler
  jmp exit_irq
 
test_cb2:
  asl
  bcc test_ca1
  bit PORTB_1
  jsr cb2_handler
  jmp exit_irq
 
test_ca1:
  asl           ; shift CA1 bit into the CARRY bit & test
  asl
  bcc exit_irq        ; carry clear = leave
  jsr keypad_handler  ; carry not clear = handle the CA1 interrupt (keypad)
  jmp exit_irq
 
 
next_device:
 
exit_irq:
  ply
  plx
  pla
 
 
  rti
 
emt: .asciiz "hhh mm ss  MET"
splash: .asciiz "cmon> "
error_message: .asciiz "Not Decimal"
mem_pass_msg: .asciiz "RAM Test Pass"
mem_fail_msg_1: .asciiz "RAM Test 1 Fail"
mem_fail_msg_2: .asciiz "RAM Test 2 Fail"
 
; Reset/IRQ vectors
 
.segment "VECTORS"
 
 
  .word nmi
  .word reset
  .word irq

See CA65 Setup for the details of the additional includes files needed to assemble the code.

Notes

The idea of basic features came from

http://www.suppertime.co.uk/blogmywiki/2021/03/6502-breadboard-computer-part-7-working-monitor/

https://www.youtube.com/watch?v=TK2JIZREgYM

My version is similar, but different.

The Keypad scanning routine came from :

https://www.asinine.nz/2022-05-01/6502-part4/

I wanted to write a routine to poll the 16-key pad and needed some hints. I understood what was needed, but was uncertain about the best way to achieve the correct results, so I looked at various bits of code online. When I worked through this snippet I understood what it was doing, and could perhaps in future come up with a similar working solution myself. It's all a matter of studying, understanding and then using the new knowledge. In the meantime this snippet of code works well enough that I see no point in re-inventing the wheel, so I'm just using it verbatim.

To allow key presses to trigger interrupts I have to set the 4 row-outputs (PA4-PA7) high and then diode-OR the switch's column lines, feeding this OR'd signal in to CA1 on the 65c22. Pressing any key pulls CA1 high, triggering an interrupt, and the interrupt routine then calls the keypad reading function itself which then determines which key was pressed.

— John Pumford-Green 27/08/22 09:24

Further Information

6502, assembly

Photos

anonymous@undisclosed.example.com (Anonymous) — Thu, 29 Jan 2026 13:22:23 +0000

←6502 Project

Photos

Some pics of the project

Version 1 - veroboard

Mark 1 in all its glory

Twin LCD displays. 2-line for RTC and Uptime. 4 Line for monitor.

RTC Chip and 2 debounced push buttons on the top breadboard. RTC is fed with 32.768kHz from a function generator awaiting for a new xtal.

4-input AND gate for VIA IRQ connection to CPU on the other breadboard.

I/O board with 2 65C22 VIAs. Beeper piezo sounder in the Altoids tin.

Version 2

Planned to be built using Wirewrap methods but seems to have been forgotten about
- I'll possibly return to the project in winter 2024/5?

— John Pumford-Green 29/09/22 08:21

Further Information

6502 Setup

anonymous@undisclosed.example.com (Anonymous) — Tue, 30 Dec 2025 09:55:07 +0000

←6502 Project

6502 Setup

Various pre-requisites

Vim Syntax Highlighting

To get better syntax highlighting for 6502 assembler I found a vim syntax file asmM6502.vim

https://github.com/jestin/asmM6502.vim

This was saved as ~/.vim/syntax/asmM6502.vim

To make sure assembler source code used the 6502 syntax add:

autocmd BufRead,BufNewFile *.s,*.asm,*.inc set filetype=asmM6502

to ~/.vimrc

Vim in action

Assembler compiler VASM

To compile source to machine-code suitable for blowing onto EEPROM use the vasm compiler

It's possible to self-compile VASM by downloading the source-code from:

http://sun.hasenbraten.de/vasm/

but there are ready made binaries here, specifically for the 6502 old-style binaries:

http://www.compilers.de/vasm.html

Use the link at the foot of the page:

http://www.ibaug.de/vasm/vasm6502.zip

Download, unzip (extracts the files needed into ../vasm6502_oldstyle/linux/)

sudo cp ./vasm6502_oldstyle/linux/* /usr/local/bin

Add an alias to ~/.bashrc

alias vasm='vasm6502_oldstyle -Fbin -dotdir'

for the most used options

To compile a source file to a binary a.out file:

vasm hello_world.s

hello_world.s

PORTB = $6000
PORTA = $6001
DDRB = $6002
DDRA = $6003
 
E  = %10000000
RW = %01000000
RS = %00100000
 
  .org $8000
 
reset:
  ldx #$ff
  txs
 
  lda #%11111111 ; Set all pins on port B to output
  sta DDRB
  lda #%11100000 ; Set top 3 pins on port A to output
  sta DDRA
 
  lda #%00111000 ; Set 8-bit mode; 2-line display; 5x8 font
  jsr lcd_instruction
  lda #%00001110 ; Display on; cursor on; blink off
  jsr lcd_instruction
  lda #%00000110 ; Increment and shift cursor; don't shift display
  jsr lcd_instruction
  lda #$00000001 ; Clear display
  jsr lcd_instruction
 
  ldx #0
print:
  lda message,x
  beq loop
  jsr print_char
  inx
  jmp print
 
loop:
  jmp loop
 
message: .asciiz "Hello, world!"
 
lcd_wait:
  pha
  lda #%00000000  ; Port B is input
  sta DDRB
lcdbusy:
  lda #RW
  sta PORTA
  lda #(RW | E)
  sta PORTA
  lda PORTB
  and #%10000000
  bne lcdbusy
 
  lda #RW
  sta PORTA
  lda #%11111111  ; Port B is output
  sta DDRB
  pla
  rts
 
lcd_instruction:
  jsr lcd_wait
  sta PORTB
  lda #0         ; Clear RS/RW/E bits
  sta PORTA
  lda #E         ; Set E bit to send instruction
  sta PORTA
  lda #0         ; Clear RS/RW/E bits
  sta PORTA
  rts
 
print_char:
  jsr lcd_wait
  sta PORTB
  lda #RS         ; Set RS; Clear RW/E bits
  sta PORTA
  lda #(RS | E)   ; Set E bit to send instruction
  sta PORTA
  lda #RS         ; Clear E bits
  sta PORTA
  rts
 
  .org $fffc
  .word reset
  .word $0000

gm4slv@laptop:~/6502 $ vasm hello_world.s
vasm 1.8h (c) in 2002-2019 Volker Barthelmann
vasm 6502 cpu backend 0.8 (c) 2002,2006,2008-2012,2014-2018 Frank Wille
vasm oldstyle syntax module 0.13f (c) 2002-2018 Frank Wille
vasm binary output module 1.8a (c) 2002-2009,2013,2015,2017 Volker Barthelmann
 
seg8000(acrwx1):                 143 bytes
segfffc(acrwx1):                   4 bytes

Inspect the hexcode in the binary file hexdump

gm4slv@laptop:~/6502 $ hexdump -C a.out
00000000  a2 ff 9a a9 ff 8d 02 60  a9 e0 8d 03 60 a9 38 20  |.......`....`.8 |
00000010  63 80 a9 0e 20 63 80 a9  06 20 63 80 a9 01 20 63  |c... c... c... c|
00000020  80 a2 00 bd 32 80 f0 07  20 79 80 e8 4c 23 80 4c  |....2... y..L#.L|
00000030  2f 80 48 65 6c 6c 6f 2c  20 77 6f 72 6c 64 21 00  |/.Hello, world!.|
00000040  48 a9 00 8d 02 60 a9 40  8d 01 60 a9 c0 8d 01 60  |H....`.@..`....`|
00000050  ad 00 60 29 80 d0 ef a9  40 8d 01 60 a9 ff 8d 02  |..`)....@..`....|
00000060  60 68 60 20 40 80 8d 00  60 a9 00 8d 01 60 a9 80  |`h` @...`....`..|
00000070  8d 01 60 a9 00 8d 01 60  60 20 40 80 8d 00 60 a9  |..`....`` @...`.|
00000080  20 8d 01 60 a9 a0 8d 01  60 a9 20 8d 01 60 60 00  | ..`....`. ..``.|
00000090  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
00007ff0  00 00 00 00 00 00 00 00  00 00 00 00 00 80 00 00  |................|
00008000

minipro EEPROM programmer

An open source project minipro to use the TI866 USB EEPROM programmer under Linux

git clone https://gitlab.com/DavidGriffith/minipro.git
cd minipro
make
sudo make install

to burn an EEPROM

minipro -p AT28C256 -w a.out

— John Pumford-Green 10/08/22 13:50

Further Information

Sept' 2022 : Moved to CA65 assembler.

CA65 Setup

6502

6502 Project

anonymous@undisclosed.example.com (Anonymous) — Tue, 30 Dec 2025 09:55:07 +0000

←Computers

6502 Project

My New 2022 Project

I've never really considered myself to be a programmer. I dabble very badly in Python but I've always been confused by what goes on at the CPU level.

Assembler & Machine Code seem to be where you get to grips with what's really happening.

I'm going to build a small 6502-based computer, with the bare minimum of hardware & features…. CPU, ROM, RAM, I/O and some form of display.

I was going to source the parts myself, but found it impossible to find a supplier with stock of the usual 28C256 EEPROM. I've been watching the excellent You Tube video series by Ben Eater:

https://youtube.com/playlist?list=PLowKtXNTBypFbtuVMUVXNR0z1mu7dp7eH

Ben supplies a kit with everything needed to build the basic computer - just add a PSU and an EEPROM programmer - so I've bought one of his kits.

https://eater.net/6502

I've ordered a TL866 programmer from Amazon as well as a well-regarded book Programming the 65816: Including the 6502, 65C02, and 65802

Tutorial Progress

anonymous@undisclosed.example.com (Anonymous) — Tue, 30 Dec 2025 09:55:07 +0000

←6502 Project

Tutorial Progress

A record of my progress through the Ben Eater You Tube tutorial

Day One : Tuesday 16/8/22

Kit arrived
Installed:
- CPU
- EEPROM
- NAND Gate
- Address & Data lines between CPU and EEPROM and address decoder for EEPROM
Used python “makerom.py” script to burn eprom:

rom = bytearray([0xea] * 32768 )
 
rom[0] = 0xa9
rom[1] = 0x42
 
rom[2] = 0x8d
rom[3] = 0x00
rom[4] = 0x60
 
rom[0x7ffc] = 0x00
rom[0x7ffd] = 0x80
 
with open("rom.bin", "wb") as out_file:
     out_file.write(rom)

ROM file hexdump:

00000000  a9 42 8d 00 60 ea ea ea  ea ea ea ea ea ea ea ea  |.B..`...........|
00000010  ea ea ea ea ea ea ea ea  ea ea ea ea ea ea ea ea  |................|
*
00007ff

Unable to confirm correct running - still waiting for Arduino Mega to act as a logic analyzer. LEDs on data or Address lines show activity….

Next stage

add the 65C22 VIA and use LEDs on output to show correct running

make an 8-bit binary counter with LEDs as an exercise

Day Two : Wednesday 17/8/22

Using Siglent Function Generator as the CPU PHI2 clock

added 65C22 VIA and 8 leds
much debugging of hardware/wiring - breadboard is a NASTY way of doing this…..!
- ordered some IC sockets & other hardware to allow me to build a version on Vero/perf board and move away from breadboard once I've got the the point in the tutorials where all the hardware is stable.
used python script to get the “01010101 → 10101010” LED sequence running.

Self-study

modified assembly code to make the LEDs flash in a binary count

8 bit counter

### 8-bit Counter
 
code = bytearray([
    0xa9, 0xff,         # lda #$FF
    0x8d, 0x02, 0x60,   # sta $6002 : put 11111111 into VIA's Port B control register - all port pins are OUTPUT
 
    0xa9, 0xff,         # lda #$ff (start with all LEDs lit)
    0x8d, 0x00, 0x60,   # sta $6000
 
    0x1a,                # inc A
 
    0x4c, 0x07, 0x80,   # jmp $8007
    ])
 
 
rom = code + bytearray([0xea] * (32768 - len(code)))
 
rom[0x7ffc] = 0x00
rom[0x7ffd] = 0x80
 
with open("rom.bin", "wb") as out_file:
     out_file.write(rom);

This assembles as :

00000000  a9 ff 8d 02 60 a9 ff 8d  00 60 1a 4c 07 80 ea ea  |....`....`.L....|
00000010  ea ea ea ea ea ea ea ea  ea ea ea ea ea ea ea ea  |................|
*
00007ff0  ea ea ea ea ea ea ea ea  ea ea ea ea 00 80 ea ea  |................|
00008000

LEDs flash in binary count to 255 and cycle round… endlessly.

16 bit counter

I wanted to see if I could extend the counter to 16-bits, using 2 VIA ports to drive the LEDs

To make life easier I moved to assembly language and the VASM assembler as recommended in the tutorial.

To count beyond a single 8-bit byte needs a way of holding 2 separate bytes of the count, the low byte and high byte, and only increment the high byte when the low byte rolls past 11111111. Tricky with no RAM installed yet.

I used the 2 index registers X and Y. The carry bit is set as a result of arithmetic on the Accumulator register, so X (low byte) has to be copied to the Accumulator for the addition of 1 each time round the loop.

        .org $8000
 
reset:
        lda #$ff
        sta $6002    ; set port B pins to all output
        sta $6003    ; set port A pins to all output
        lda #$00
        tax          ; X holds the low byte. initialize to zero
        tay          ; Y holds the high byte. initialize to zero
 
 
loop:
        txa          ; copy low byte to A
        adc #$01     ; add 1
        tax          ; copy new value to X
        bcs high_b   ; if carry flag set, branch to increment the high byte
 
 
print:
        txa          ; bring the low byte to A
        sta $6000    ; send low byte to Port B LEDs
        tya          ; bring the high byte to A
        sta $6001    ; send high byte to Port A LEDs
        jmp loop
 
high_b:
 
        iny          ; increment high byte in Y
        jmp print
 
        .org $fffc
        .word reset
        .word $0000

Assembled code

00000000  a9 ff 8d 02 60 8d 03 60  a9 00 aa a8 8a 69 01 aa  |....`..`.....i..|
00000010  b0 0b 8a 8d 00 60 98 8d  01 60 4c 0c 80 c8 4c 12  |.....`...`L...L.|
00000020  80 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
00007ff0  00 00 00 00 00 00 00 00  00 00 00 00 00 80 00 00  |................|
00008000

Add another 8 LEDs, to Port A, to show the High Byte….

It now counts to 1111111111111111 or $FFFF or 65535 as displayed by the LEDs attached to both VIA ports.

Next stage

is to add the LCD module in place of the flashing LEDs

Day Three : Friday 19/8/22

LCD

added the LCD module to the VIA output port(s)
put the “hello.s” assembled code into ROM
LCD printed Hello, w and no more….

8 Characters… what, why?

Lots of messing about with the assembler code to see if I could get all the Hello, world! message to print to the LCD.

By adding the necessary instruction to change the display position I could use all 16 characters of the display, but I couldn't get it to print all the message in one go…. The same happened with a different LCD module.

Eventually I checked, and re-checked, the address and data lines between CPU, ROM and VIA and must have re-inserted one that was loose. Afterwards the display showed Hello, world! correctly.

I assume the error was that an address line between CPU and ROM wasn't connected, so at one step of the program the ROM went to the wrong address and returned garbage data, and the program stopped, or just randomly stepped through the otherwise empty ROM?

Anyway, whatever the mechanism, ensuring all address & data lines were seated correctly cured the bug.

Next Stage

adding RAM
rebuilding on “properly wired” stripboard to remove the annoyance of breadboard wires coming adrift.

Day 4 : Saturday 21/8/22

added RAM
re-wrote “hello_world” to use 4-bit LCD addressing and moved LCD to PORTB of VIA, freeing up all of PORTA for other uses
began building veroboard version to

Day 5 : Sunday 22/8/22

completed veroboard build and tested with 4-bit/2-line LCD “Hello world”

 
PORTB = $6000
PORTA = $6001
DDRB = $6002
DDRA = $6003
 
 
E  = %01000000
RW = %00100000
RS = %00010000
LED = %10000000
 
  .org $8000
 
reset:
  ldx #$ff
  txs
 
  lda #%11111111 ; Set all pins on port B to output
  sta DDRB
  lda #%00000000 ; Set all pins on port A to input
  sta DDRA
 
  jsr lcd_init
  lda #%00101000 ; Set 4-bit mode; 2-line display; 5x8 font
  jsr lcd_instruction
  lda #%00001110 ; Display on; cursor on; blink off
  jsr lcd_instruction
  lda #%00000110 ; Increment and shift cursor; don't shift display
  jsr lcd_instruction
  lda #%00000001 ; Clear display
  jsr lcd_instruction
 
  ldx #0
 
print1:
  lda message1,x
  beq print2
  jsr print_char
  inx
  jmp print1
 
message1: .asciiz "Shed-o-tron II "
 
message2: .asciiz "* * 22/8/22 * * "
 
 
loop:
  lda #LED
  sta PORTB
  jmp loop
 
print2:
  lda #%10101001
  jsr lcd_instruction
 
  ldx #0
line2:
  lda message2,x
  beq loop
  jsr print_char
  inx
  jmp line2
 
 
 
lcd_wait:
  pha
  lda #%11110000  ; LCD data is input
  sta DDRB
lcdbusy:
  lda #RW
  sta PORTB
  lda #(RW | E)
  sta PORTB
  lda PORTB       ; Read high nibble
  pha             ; and put on stack since it has the busy flag
  lda #RW
  sta PORTB
  lda #(RW | E)
  sta PORTB
  lda PORTB       ; Read low nibble
  pla             ; Get high nibble off stack
  and #%00001000
  bne lcdbusy
 
  lda #RW
  sta PORTB
  lda #%11111111  ; LCD data is output
  sta DDRB
  pla
  rts
 
lcd_init:
  lda #%00000010 ; Set 4-bit mode
  sta PORTB
  ora #E
  sta PORTB
  and #%00001111
  sta PORTB
  rts
 
lcd_instruction:
  jsr lcd_wait
  pha
  lsr
  lsr
  lsr
  lsr            ; Send high 4 bits
  sta PORTB
  ora #E         ; Set E bit to send instruction
  sta PORTB
  eor #E         ; Clear E bit
  sta PORTB
  pla
  and #%00001111 ; Send low 4 bits
  sta PORTB
  ora #E         ; Set E bit to send instruction
  sta PORTB
  eor #E         ; Clear E bit
  sta PORTB
  rts
 
print_char:
  jsr lcd_wait
  pha
  lsr
  lsr
  lsr
  lsr             ; Send high 4 bits
  ora #RS         ; Set RS
  sta PORTB
  ora #E          ; Set E bit to send instruction
  sta PORTB
  eor #E          ; Clear E bit
  sta PORTB
  pla
  and #%00001111  ; Send low 4 bits
  ora #RS         ; Set RS
  sta PORTB
  ora #E          ; Set E bit to send instruction
  sta PORTB
  eor #E          ; Clear E bit
  sta PORTB
  rts
 
 
 
 
 
 
 
 
; Reset/IRQ vectors
  .org $fffc
  .word reset
  .word $0000

Next Stage

begin expanding software
- routines to examine memory contents and display (in HEX) the contents of selected memory location(s)
- add switches to VIA PORTA and begin reading state of switches and update LCD with information
- a power-on memory test and toggle LED/LCD?

Further Information

Github : https://github.com/gm4slv/6502

6502

Update Sept 2022

anonymous@undisclosed.example.com (Anonymous) — Wed, 31 Jul 2024 11:12:24 +0000

←6502 Project

Update Sept 2022

Some recent modifications and additions

Hardware

2 more 65C22 VIA chips to give a total of 3 VIAs providing six 8-bit I/O ports.
- VIA #1 ($6001) : Port A = Keypad
- VIA #1 ($6000) : Port B = LCD_1 (4×20 in 4-bit mode)
  - VIA #1 : IRQ connection to CPU for keypad and CB1 & CB2 buttons
  - VIA #1 Port B handshaking CB1 and CB2 connected to debounced buttons for user input experiments
- VIA #2 ($5001) : Port A = Spare
- VIA #2 ($5000) : Port B = SPI (bit0,1,2,6), Piezo Sounder (bit7)
  - VIA #2 : T1 Timer = square wave generator for sounder using Port B bit7
- VIA #3 ($4801) : Port A = LCD_2 (2×16 in 4-bit mode)
- VIA #3 ($4800) : Port B = Spare
  - VIA #3 : T1 Timer = System Clock Ticks at 10ms rate via NMI connection to CPU
main LCD changed to a 4 line by 20 character display
2nd LCD (2 x 16) added on VIA #3 Port A
LED indicator plug-in boards made to give easy visual indication of VIA output port state
Piezo sounder connected to VIA #2 Port B, bit 7
SPI interfacing using VIA #2 Port B
Buttons for controlling interrupt driven events, each de-bounced with a 555 monostable
555 timer as a power-on CPU reset

Firmware

ROM Monitor code extended to support the new hardware.

SPI transceive to communicate with a basic SPI slave running on a PyBoard
LCD #2 display of either “Mission Time” or SPI TX/RX data to/from PyBoard
code to send audible beeps of different pitch/duration (controlled by the 2 buttons)
keypad - confirmation keypress beeps
Byte (binary) to ASCII decimal conversion to show 16-bit/2-byte binary data as a human readable decimal number
Use of FLAGS to control background tasks extended/explored

Next Steps

add Serial Interface using Rockwell 65C51 ACIA and MAX232
learn how to code for interacting via serial interface
connect to a Wyse-185 Serial Terminal
[✓ John Pumford-Green, 2022-09-26]~~add DS1306 RTC via SPI~~
[✓ John Pumford-Green, 2022-09-26]~~move system clock back to VIA_1 using IRQ interrupt~~
[✓ John Pumford-Green, 2022-09-26]~~move beep to VIA_3 port B7~~
[✓ John Pumford-Green, 2022-09-26]~~move SPI interface to VIA_3 port B, for future connection to DS1306 RTC~~
- this will leave :
  - VIA_2 ports A & B free for external use
  - VIA_3 Port A = LCD2
  - VIA_3 Port B = Beep and SPI/RTC

— John Pumford-Green 17/09/22 11:50

Further Information

6502, assembly

John's Vademecum - public:computers:6502

6502 based homebrew computer

6502 based homebrew computer

CA65 Setup

CA65 Setup

Support Files

A typical project

monitor_dev.s setup

Variables

monitor_dev.s source code

Further Information

Datasheets

Datasheets

CPU

EEPROM

RAM

LCD

VIA

ACIA

RTC

Various support chips

Further Information

Goals : 6502

Goals : 6502

Phase One

Phase Two

Phase Three

Further Information

Links

Links

You Tube

General

Personal Project/Blogs Pages

Tools

Further Information

Monitor

Monitor

Features

monitor_dev.s

Notes

Further Information

Photos

Photos

Version 1 - veroboard

Version 2

Further Information

6502 Setup

6502 Setup

Vim Syntax Highlighting

Vim in action

Assembler compiler VASM

minipro EEPROM programmer

Further Information

6502 Project

6502 Project

My New 2022 Project

Tutorial Progress

Tutorial Progress

Day One : Tuesday 16/8/22

Next stage

Day Two : Wednesday 17/8/22

Self-study

8 bit counter

16 bit counter

Next stage

Day Three : Friday 19/8/22

LCD

Next Stage

Day 4 : Saturday 21/8/22

Day 5 : Sunday 22/8/22

Next Stage

Further Information

Update Sept 2022

Update Sept 2022

Hardware

Firmware

Next Steps

Further Information