I recently tested the SC16C752 UART from NXP with my 6502 computer, and I was able to use it to receive and send characters. This blog post shows the simple test program and circuit that I used.
I am now building a 16-bit computer, and I want to avoid the 65C51N, for two main reasons:
- It runs at 5v, and I’m planning to convert the design to 3.3v later on. The other 65-series chips I’m using support a wide voltage range.
- It can only store one byte at a time. I am planning to run at a higher baud rate, and the system will have multiple interrupt sources. It would take very careful programming to avoid losing bytes with a 65C51N in this setup.
I spent some time investigating alternative UART IC’s, and found some discussion on 6502.org about replacing the 6551 with an NXP industrial (SC26 or SC28 series) UART. At the time of writing, many of the hobbyist-friendly PLCC versions of these chips are listed as end of life, though I’ve since found pin and software-compatible versions of this made by MaxLinear (eg. the XR88C92).
For my uses though, I chose the NXP SC16C752. It has two channels, 64-byte receive and transmit buffers, and supports a wide voltage range. I don’t mind that it’s a different series to these standard chips, because I plan to write software from scratch. The only downside is the packaging, which is LQFP48 with 0.5mm pin pitch. I needed to solder this tiny chip to an adapter board in order to use it.
The test circuit
I wired this up to my 6502 computer project as shown in the diagram below.
IO3 is a spare address decoding output, which maps the chip to address
$8c00, while the rest of the signals connect to the 6502 CPU directly.
I used a 74AC00 and 74AC04 to generate the active-high reset and separate read/write signals (as suggested on the same thread linked before). I plan to use a PLD to generate a qualified write signals on my 65C816 computer build.
Note that there are separate chip-selects for each UART, and I’ve only connected one here. I have also not connected the interrupt output for this test, and have some unused inputs which are left floating.
Developing a test program
I started writing some code, and connected a logic analyser to the UART output. The early tests did not work well, and I now know that this is because I had not enabled the FIFOs, causing characters to be lost.
This screen capture shows an attempt to send the entire alphabet to the UART, but only the letters “A”, “B” and “M” appearing at the output.
I came up with this test program, which does 8-N-1 communication at 115,200 bits per second.
; ; Test program for the SC16C752B dual UART from NXP ; .import sys_exit ; Assuming /CSA is connected to IO3 UART_BASE = $8c00 ; UART registers ; Not included: FIFO ready register, Xon1 Xon2 words. UART_RHR = UART_BASE ; Receiver Holding Register (RHR) - R UART_THR = UART_BASE ; Transmit Holding Register (THR) - W UART_IER = UART_BASE + 1 ; Interrupt Enable Register (IER) - R/W UART_IIR = UART_BASE + 2 ; Interrupt Identification Register (IIR) - R UART_FCR = UART_BASE + 2 ; FIFO Control Register (FCR) - W UART_LCR = UART_BASE + 3 ; Line Control Register (LCR) - R/W UART_MCR = UART_BASE + 4 ; Modem Control Register (MCR) - R/W UART_LSR = UART_BASE + 5 ; Line Status Register (LSR) - R UART_MSR = UART_BASE + 6 ; Modem Status Register (MSR) - R UART_SPR = UART_BASE + 7 ; Scratchpad Register (SPR) - R/W ; Different meaning when LCR is logic 1 UART_DLL = UART_BASE ; Divisor latch LSB - R/W UART_DLM = UART_BASE + 1 ; Divisor latch MSB - R/W ; Different meaning when LCR is %1011 1111 ($bh). UART_EFR = UART_BASE + 2 ; Enhanced Feature Register (EFR) - R/W UART_TCR = UART_BASE + 6 ; Transmission Control Register (TCR) - R/W UART_TLR = UART_BASE + 7 ; Trigger Level Register (TLR) - R/W .segment "CODE" main: lda #$80 ; Enable divisor latches sta UART_LCR lda #1 ; Set divisior to 1 - on a 1.8432 MHZ XTAL1, this gets 115200bps. sta UART_DLL lda #0 sta UART_DLM lda #%00010111 ; Sets up 8-n-1 sta UART_LCR lda #%00001111 ; Enable FIFO, set DMA mode 1 sta UART_FCR jsr test_print jsr test_recv lda #0 jmp sys_exit test_print: ; Send test string to UART ldx #0 @test_char: lda test_string, X beq @test_done sta UART_THR inx jmp @test_char @test_done: rts test_string: .asciiz "Hello, world!" test_recv: ; Receive three characters and echo them back jsr uart_recv_char sta UART_THR jsr uart_recv_char sta UART_THR jsr uart_recv_char sta UART_THR rts uart_recv_char: ; Receive next char to A register lda UART_LSR and #%00000001 cmp #%00000001 bne uart_recv_char lda UART_RHR rts
The program sends the text “Hello, world!”, then waits for input. The next three characters it receives are sent back to the user, and then the program terminates. The only thing in this test program which is specific to my 6502 computer is
sys_exit, which a routine to transfer control back to the operating system.
It was very rewarding to see the fast, error-free text output on the logic analyser for the first time. This is a great improvement from the 65C51N.
I was also surprised at how short the delay is to echo back a character. It will be interesting to see how much the latency increases once there is some more complex software handling the input.
Wrap up and next steps
I plan to use the NXP SC16C752 for my 65C816 computer project, which will be controlled via text-based input and output.
I’m testing it on its own first, so that I can refer to a known-good setup if it doesn’t work. This is enough to get started, though there are some features which I wasn’t able to test yet, since I can’t use custom interrupt service routines on this setup.