How text mode works
This is a
follow-up of the FPGA computer post.
In this post I will give more details about the text mode of the FPGA computer. The text mode is the default mode for the computer. When the computers powers up, this is the default mode.
In this post I will give more details about the text mode of the FPGA computer. The text mode is the default mode for the computer. When the computers powers up, this is the default mode.
Text mode is 80x60 characters, occupying 4800 words, or 9600 bytes, starting from the address of
2400.
Lower byte is the ASCII code of a character, while the upper byte contains the attributes:
|
7
|
6
|
5
|
4
|
3
|
2
|
1
|
0
|
|
|
Foreground color,
inverted
|
|
Background color
|
||||
|
|
|
r
|
g
|
b
|
r
|
g
|
b
|
The foreground color is inverted so zero values (default) would mean white color. That way, you don't
need to set the foreground color to white, and by default (0, 0, 0), it is white. The default background
color is black (0, 0, 0). This means that if the upper (Attribute) byte is zero (0x00), the background
color is black, and the foreground color is white.
I have used Ken Shirriff's blog post FizzBuzz a lot for this implementation. I highly recommend his
posts!
Verilog implementation relies on the character ROM. Character ROM is implemented as a separate Verilog module, and is used like this:
Verilog implementation relies on the character ROM. Character ROM is implemented as a separate Verilog module, and is used like this:
// Character generator
chars chars_1(
.char(curr_char[7:0]),
.rownum(y[2:0]),
.pixels(pixels)
);
Current character (which is read from the address
of 2400, up to the 2400+9600) is received in the curr_char register.
This register is wired to the chars module, together with two additional parameters:
rownum (wired to the y register - the y coordinate) and the
pixels output register (this register will hold the pixels of the current
character, for the current y coordinate).
The chars module itself
is a giant switch statement:
always
@(*)
case ({char, rownum})
11'b00110000000: pixels = 8'b01111100; //
XXXXX
11'b00110000001: pixels = 8'b11000110; // XX
XX
11'b00110000010: pixels = 8'b11001110; // XX
XXX
11'b00110000011: pixels = 8'b11011110; // XX
XXXX
11'b00110000100: pixels = 8'b11110110; // XXXX
XX
11'b00110000101: pixels = 8'b11100110; // XXX
XX
11'b00110000110: pixels = 8'b01111100; //
XXXXX
11'b00110000111: pixels = 8'b00000000; //
11'b00110001000: pixels = 8'b00110000; // XX
11'b00110001001: pixels = 8'b01110000; // XXX
11'b00110001010: pixels = 8'b00110000; // XX
11'b00110001011: pixels = 8'b00110000; // XX
11'b00110001100: pixels = 8'b00110000; // XX
11'b00110001101: pixels = 8'b00110000; // XX
11'b00110001110: pixels = 8'b11111100; //
XXXXXX
11'b00110001111:
pixels = 8'b00000000; //
As you can see, the input character and the y coordinate
are concatenated to determine which row of pixels will be returned to the vga text
module.
How is the
current_char obtained? There are three distinctive situations
when this byte is obtained:
1. during the visible scanline processing. During this
case, we wait for the last column (pixel) of the current character to be displayed, and
then we fetch the next character:
else if (x < 640 && !mem_read) begin
if ((x & 7) == 7) begin
// when we are finishing current character,
// we need to fetch in advance
// the next character (x+1, y)
// (at the last pixel of the current character, let's fetch next)
rd <= 1'b1;
wr <= 1'b0;
addr <= VIDEO_MEM_ADDR + ((x >> 3) + (y >> 3)*80 + 1);
mem_read <= 1'b1;
end
end
2. during the horizontal blanking. During this case, we need to obtain either the current character (we haven't finished the current row yet), or the next character in the next row:
else if (x < 640 && !mem_read) begin
if ((x & 7) == 7) begin
// when we are finishing current character,
// we need to fetch in advance
// the next character (x+1, y)
// (at the last pixel of the current character, let's fetch next)
rd <= 1'b1;
wr <= 1'b0;
addr <= VIDEO_MEM_ADDR + ((x >> 3) + (y >> 3)*80 + 1);
mem_read <= 1'b1;
end
end
2. during the horizontal blanking. During this case, we need to obtain either the current character (we haven't finished the current row yet), or the next character in the next row:
else if ((x >= 640)
&& ((y & 7) < 7)) begin
// when we start the horizontal
blanking,
// and still displaying character in the current
row,
// we need to fetch in
advance
// the first character in the current row (0,
row)
rd <= 1'b1;
wr <= 1'b0;
addr <= VIDEO_MEM_ADDR + ((y >>
3)*80);
mem_read <= 1'b1;
end
else if ((x >= 640)
&& ((y & 7) == 7)) begin
// when we start the horizontal
blanking,
// and we need to go to the next
line,
// we need to fetch in advance the first
character in next row (0, row+1)
rd <= 1'b1;
wr <= 1'b0;
addr <= VIDEO_MEM_ADDR + (((y >>
3) + 1)*80);
mem_read <= 1'b1;
end
3. during the vertical blanking. In this case, we need to fetch the
first character, at the beginning of the frame buffer:
if ((x >= 640) &&
(y >= 480)) begin
// when we start the vertical
blanking,
// we need to fetch in advance the first character (0,
0)
rd <= 1'b1;
wr <= 1'b0;
addr <= VIDEO_MEM_ADDR + 0;
mem_read <= 1'b1;
end
The code above sets the address bus and control lines. The
character is then fetched from the data bus:
if (mem_read)
begin
curr_char <=
data;
rd <= 1'bz;
wr <= 1'bz;
mem_read <=
1'b0;
end
The character is wired to
the character ROM, and the output is placed in the pixels
register. From that point, the pixels are shifted bit by bit to the r, g, and b
wires of VGA connector:
if (valid)
begin
r <= pixels[7 - (x & 7)] ?
!curr_char[6+8] : curr_char[2+8];
g <= pixels[7 - (x & 7)] ?
!curr_char[5+8] : curr_char[1+8];
b <= pixels[7 - (x & 7)] ?
!curr_char[4+8] : curr_char[0+8];
end
else begin
// blanking -> no pixels
r <= 1'b0;
g <= 1'b0;
b <= 1'b0;
end
It is interesting how horizontal and vertical sync pulses
are generated:
assign hs = x <
(640 + 16) || x >= (640 + 16 + 96);
assign vs = y <
(480 + 10) || y >= (480 + 10 + 2);
assign valid = (x
< 640) && (y < 480);
Just by wiring
hs an vs one-bit registers
to the VGA connector and by assigning to them expressions above, horizontal
and vertical sync pulses are generated according to the current state of the
x and y counters. When the
x counter reaches 640 + 10, it is the end of the
current scanline and the hs pulse is low (inverted
logic). Similarly, the vs pulse is low when the
y counter (the line counter) reaches 480 +
10.
If you look at
the value range of the x and y
registers, you will see that the x
goes from 0 to 799, while y goes from
0 to 524. This means that the actual resolution of the VGA 640x480 mode
is 800x525. However, during the horizontal and vertical blanking some of
those pixels (and also lines) are not visible, so the actual visible
pixels are from the 640x480 range. That is detected in the
"assign valid =..." line of the code
above.
Programming in assembler
Assembler
examples can be found here.
Following assembler code writes a string with color attributes.
Following assembler code writes a string with color attributes.
mov r1, hello ; r1 holds
the address of the "Hello World!" string
mov r2, 0 ; r2 is the
index
mov r3, 0 ; r3 has
the attribute
again:
ld.b r0, [r1] ; load r0
with the content of the memory location to which r1 points
(current character)
cmp r0, 0 ; if the
current character is 0 (string terminator),
jz end ; go out of
this loop
st.b [r2 + VIDEO_1], r3;
store the attribute
inc r2 ; move to the
character location
st.b [r2 + VIDEO_1], r0;
store the character at the VIDEO_0 + r2
inc r1 ; move to the next
character in the string
inc r2 ; move to
the next location (attribute) in video
memory
inc r3 ; change
the attribute of the current character
j again ; continue
with the loop
end:
halt
hello:
#str "Hello
World!\0"
The result is on the image below.
In the emulator, it looks like this:
Conclusion
The text mode is
implemented by reading the character from the framebuffer, and then by
obtaining its pixels from the character ROM. When those pixels are obtained,
they are shifted one by one to the VGA connector, to the corresponding r, g
and b wires. That way, the character is shown on the screen. I have
implemented the text mode first, and then l have implemented the graphics
mode. Both modes are surprisingly simple to be implemented in
Verilog.
Text mode module is on the github.