My initial board has the UART as the only I/O device, so it's directly connected to the Z80 CPU - meaning its I/O address starts at $00. This is important when it comes to
addressing the UART's registers - obviously if you do this with I/O decoding your UART(s) will be in different locations, so change your addressing accordingly.
Configuring the UART
The first step in working with a UART is to configure the device so it knows what kind of line speed to use (baud rate) and the byte size/parity/stop bits configuration that
you're going to use. You must match both ends of the serial link in these settings, and in my case I was going to use a dumb terminal (initially a DEC VT240, then later a
Linux laptop running minicom), which I planned on connecting to at 9600bps, 8N1 (8-bit byte, No parity, 1 stop bit).
The UART takes a clock source which you then must convert down to your line speed with a series of divisions - firstly, the UART runs a communication cycle every sixteen
clock ticks, so right there you divide by 16. You then must divide this again by your divisor number to get to your targeted baud rate.
In my case, I was use a 16mHz oscillator.
16mHz / 16 = 1mHz
Now I just needed to get 1mHz down to ~9600bps - it doesn't have to be exact because this is supposed to be an asynchronous protocol, but it does need to be vaguely close
1mHz / 104 = 9615.4bps
And, lo, we have our divisor - 104.
The UART's line settings are configured using three registers - the DLL (low byte of the divisor), DLM (high byte of the divisor) and LCR (line control register). However there's
a catch - the DLL and DLM are passed through the first two registers in the UART, the Transmit/Receive Register and the Interrupt Enable Register. To actually talk to the DLL/DLM
you need to latch it in - using the Divisor Latch Enable, or DLE. So first we have to set the DLE bit (bit 7) of the IER to a binary 1, then load our DLL and DLM. When we're
done with setting the baud rate, we flip the DLE back off (bit 7 of the IER to binary 0).
But before we do, we need to set the DLL and DLM to 104. 104 decimal is $0068 in hexadecimal, so the DLL needs to be set to $68 and the DLM to $00.
Finally, the DLE is set to 8N1 - this involves a bitmask, which is defined by the manufacturer, although I imagine most UART DLE registers follow the same mask, in this case
00000011
This code chunk looks like this:
LD A,10000000b ; Bitmask to set the DLE to 1 OUT ($03),A ; Write the mask to the LCR (register $03) LD A,$68 ; 104 OUT ($00),A ; Write 104 to the DLL LD A,$00 ; 00 OUT ($01),A ; Write 00 to the DLM - thus giving us a final divisor of $0068, or 104 LD A,00000011b ; Bitmask to set DLE back to 0, and configure the LCR for 8, N, 1 OUT ($03),A ; Write to the LCR
GPIO pins
Now we're getting somewhere. The UART also has a pair of general-purpose I/O pins. These are +5v pins that can be turned on and off by flipping a bit on the UART's Modem
Control Register, or MCR. For my first board I used the second GPIO pin, /OUT2, to tell me the system was up, and the other, /OUT1, toggled each time it attempted to write
a byte to the transmit buffer - like a heartbeat light, telling me it was trying to do something. I used an OR to ensure the /OUT2 pin was on, and an XOR to toggle
the /OUT1 bit in the MCR, like so:
IN A,($04) ; Read the MCR into the Accumulator OR 00001000b ; Make sure the /OUT2 GPIO pin in the bitmask is on OUT ($04),A ; Write the bitmask back out to the MCR, enabling our change ; Or, for /OUT1, toggle the bit in the mask: IN A,($04) XOR 00000100b OUT ($04),A
Writing to the terminal
So we're making good progress. The next part to work out is how to write a byte out through the UART to the terminal on the other side of the serial cable. We do this by sending
a byte to the Transmit Holding Register and then polling the Line Status Register to verify the byte has cleared, that way we're not pummelling the UART with a stream of bytes
before it has the ability to transmit them - the THR is only a single byte in size, so it is possible to overwrite it if we were sending things to it fast enough.
Now, this being said, the "right" way to do this is to use an interrupt - that way we can continue processing other things and pump bytes to the UART when it's ready. In my
case, there's nothing else to do, so polling it suits me just fine.
LD C,$00 ; Load the THR address into the B register, $00
LD B,"A" ; Put the ASCII character 'A' in the B register
OUT (C),B ; Push the contents of the B register ("A") out to the address in the C register ($00)
Loop:
IN A,($05) ; Read the LSR
BIT 6,A ; Check bit 6 on the byte read from the LSR
JP Z,Loop ; If zero, loop
JP SentByte ; Elsewise, go somewhere else
OUT (C),B - this is because you have to use an index register to talk to an I/O
Putting it all together
So, finally, here is the full chunk of code.
IN A,($04) ; Read the MCR into the Accumulator
OR 000010000b ; Make sure the /OUT2 GPIO pin in the bitmask is on
OUT ($04),A ; Write the bitmask back out to the MCR, enabling our change
LD A,10000000b ; Bitmask to set the DLE to 1
OUT ($03),A ; Write the mask to the LCR (register $03)
LD A,$68 ; 104
OUT ($00),A ; Write 104 to the DLL
LD A,$00 ; 00
OUT ($01),A ; Write 00 to the DLM - thus giving us a final divisor of $0068, or 104
LD A,00000011b ; Bitmask to set DLE back to 0, and configure the LCR for 8, N, 1
OUT ($03),A ; Write to the LCR
LD C,$00 ; Put the THR address in the C register
LD B,'A' ; Load the ASCII character 'A' in the B register
Output:
IN A,($04) ; Read the MCR
XOR 00000100b ; Toggle the /OUT1 pin
OUT ($04),A ; Write back to the MCR
OUT (C),B ; Push the contents of the B register ("A") out to the address in the C register ($00)
INC B ; Increment the letter in the B register
LD A,'[' ; The character after Z in the ASCII character map is the left square bracket, load this into A
CP B ; Compare to B
JP Z,ResetByte ; If they are the same (B is also '['), jump to ResetByte
Loop:
IN A,($05) ; Read the LSR
BIT 6,A ; Check bit 6 on the byte read from the LSR
JP Z,Loop ; If zero, loop
JP Output ; Elsewise, go back to outputting the next character
ResetByte:
LD B,'A' ; Put an ASCII 'A' back into B
JP Loop ; Jump back to the LSR polling loop