diff options
Diffstat (limited to 'vga-core/vga_controller.sv')
| -rw-r--r-- | vga-core/vga_controller.sv | 216 |
1 files changed, 216 insertions, 0 deletions
diff --git a/vga-core/vga_controller.sv b/vga-core/vga_controller.sv new file mode 100644 index 0000000..4217c13 --- /dev/null +++ b/vga-core/vga_controller.sv @@ -0,0 +1,216 @@ +// synopsys translate_off +`timescale 1 ps / 1 ps +// synopsys translate_on + +/* This module implements the VGA controller. It assumes a 25MHz clock is supplied as input. + * + * General approach: + * Go through each line of the screen and read the colour each pixel on that line should have from + * the Video memory. To do that for each (x,y) pixel on the screen convert (x,y) coordinate to + * a memory_address at which the pixel colour is stored in Video memory. Once the pixel colour is + * read from video memory its brightness is first increased before it is forwarded to the VGA DAC. + */ +module vga_controller( vga_clock, resetn, pixel_colour, memory_address, + VGA_R, VGA_G, VGA_B, + VGA_HS, VGA_VS, VGA_BLANK, + VGA_SYNC, VGA_CLK); + + /* Screen resolution and colour depth parameters. */ + + parameter BITS_PER_COLOUR_CHANNEL = 1; + /* The number of bits per colour channel used to represent the colour of each pixel. A value + * of 1 means that Red, Green and Blue colour channels will use 1 bit each to represent the intensity + * of the respective colour channel. For BITS_PER_COLOUR_CHANNEL=1, the adapter can display 8 colours. + * In general, the adapter is able to use 2^(3*BITS_PER_COLOUR_CHANNEL) colours. The number of colours is + * limited by the screen resolution and the amount of on-chip memory available on the target device. + */ + + parameter MONOCHROME = "FALSE"; + /* Set this parameter to "TRUE" if you only wish to use black and white colours. Doing so will reduce + * the amount of memory you will use by a factor of 3. */ + + parameter RESOLUTION = "320x240"; + /* Set this parameter to "160x120" or "320x240". It will cause the VGA adapter to draw each dot on + * the screen by using a block of 4x4 pixels ("160x120" resolution) or 2x2 pixels ("320x240" resolution). + * It effectively reduces the screen resolution to an integer fraction of 640x480. It was necessary + * to reduce the resolution for the Video Memory to fit within the on-chip memory limits. + */ + + parameter USING_DE1 = "FALSE"; + /* If set to "TRUE" it adjust the offset of the drawing mechanism to account for the differences + * between the DE2 and DE1 VGA digital to analogue converters. Set to "TRUE" if and only if + * you are running your circuit on a DE1 board. */ + + //--- Timing parameters. + /* Recall that the VGA specification requires a few more rows and columns are drawn + * when refreshing the screen than are actually present on the screen. This is necessary to + * generate the vertical and the horizontal syncronization signals. If you wish to use a + * display mode other than 640x480 you will need to modify the parameters below as well + * as change the frequency of the clock driving the monitor (VGA_CLK). + */ + parameter C_VERT_NUM_PIXELS = 11'd480; + parameter C_VERT_SYNC_START = 11'd493; + parameter C_VERT_SYNC_END = 11'd494; //(C_VERT_SYNC_START + 2 - 1); + parameter C_VERT_TOTAL_COUNT = 11'd525; + + parameter C_HORZ_NUM_PIXELS = 11'd640; + parameter C_HORZ_SYNC_START = 11'd659; + parameter C_HORZ_SYNC_END = 11'd754; //(C_HORZ_SYNC_START + 96 - 1); + parameter C_HORZ_TOTAL_COUNT = 11'd800; + + /*****************************************************************************/ + /* Declare inputs and outputs. */ + /*****************************************************************************/ + + input vga_clock, resetn; + input [((MONOCHROME == "TRUE") ? (0) : (BITS_PER_COLOUR_CHANNEL*3-1)):0] pixel_colour; + output [((RESOLUTION == "320x240") ? (16) : (14)):0] memory_address; + output reg [9:0] VGA_R; + output reg [9:0] VGA_G; + output reg [9:0] VGA_B; + output reg VGA_HS; + output reg VGA_VS; + output reg VGA_BLANK; + output VGA_SYNC, VGA_CLK; + + /*****************************************************************************/ + /* Local Signals. */ + /*****************************************************************************/ + + reg VGA_HS1; + reg VGA_VS1; + reg VGA_BLANK1; + reg [9:0] xCounter, yCounter; + wire xCounter_clear; + wire yCounter_clear; + wire vcc; + + reg [((RESOLUTION == "320x240") ? (8) : (7)):0] x; + reg [((RESOLUTION == "320x240") ? (7) : (6)):0] y; + /* Inputs to the converter. */ + + /*****************************************************************************/ + /* Controller implementation. */ + /*****************************************************************************/ + + assign vcc =1'b1; + + /* A counter to scan through a horizontal line. */ + always @(posedge vga_clock or negedge resetn) + begin + if (!resetn) + xCounter <= 10'd0; + else if (xCounter_clear) + xCounter <= 10'd0; + else + begin + xCounter <= xCounter + 1'b1; + end + end + assign xCounter_clear = (xCounter == (C_HORZ_TOTAL_COUNT-1)); + + /* A counter to scan vertically, indicating the row currently being drawn. */ + always @(posedge vga_clock or negedge resetn) + begin + if (!resetn) + yCounter <= 10'd0; + else if (xCounter_clear && yCounter_clear) + yCounter <= 10'd0; + else if (xCounter_clear) //Increment when x counter resets + yCounter <= yCounter + 1'b1; + end + assign yCounter_clear = (yCounter == (C_VERT_TOTAL_COUNT-1)); + + /* Convert the xCounter/yCounter location from screen pixels (640x480) to our + * local dots (320x240 or 160x120). Here we effectively divide x/y coordinate by 2 or 4, + * depending on the resolution. */ + always @(*) + begin + if (RESOLUTION == "320x240") + begin + x = xCounter[9:1]; + y = yCounter[8:1]; + end + else + begin + x = xCounter[9:2]; + y = yCounter[8:2]; + end + end + + /* Change the (x,y) coordinate into a memory address. */ + vga_address_translator controller_translator( + .x(x), .y(y), .mem_address(memory_address) ); + defparam controller_translator.RESOLUTION = RESOLUTION; + + + /* Generate the vertical and horizontal synchronization pulses. */ + always @(posedge vga_clock) + begin + //- Sync Generator (ACTIVE LOW) + if (USING_DE1 == "TRUE") + VGA_HS1 <= ~((xCounter >= C_HORZ_SYNC_START-2) && (xCounter <= C_HORZ_SYNC_END-2)); + else + VGA_HS1 <= ~((xCounter >= C_HORZ_SYNC_START) && (xCounter <= C_HORZ_SYNC_END)); + VGA_VS1 <= ~((yCounter >= C_VERT_SYNC_START) && (yCounter <= C_VERT_SYNC_END)); + + //- Current X and Y is valid pixel range + VGA_BLANK1 <= ((xCounter < C_HORZ_NUM_PIXELS) && (yCounter < C_VERT_NUM_PIXELS)); + + //- Add 1 cycle delay + VGA_HS <= VGA_HS1; + VGA_VS <= VGA_VS1; + VGA_BLANK <= VGA_BLANK1; + end + + /* VGA sync should be 1 at all times. */ + assign VGA_SYNC = vcc; + + /* Generate the VGA clock signal. */ + assign VGA_CLK = vga_clock; + + /* Brighten the colour output. */ + // The colour input is first processed to brighten the image a little. Setting the top + // bits to correspond to the R,G,B colour makes the image a bit dull. To brighten the image, + // each bit of the colour is replicated through the 10 DAC colour input bits. For example, + // when BITS_PER_COLOUR_CHANNEL is 2 and the red component is set to 2'b10, then the + // VGA_R input to the DAC will be set to 10'b1010101010. + + integer index; + integer sub_index; + + wire on_screen; + + assign on_screen = (USING_DE1 == "TRUE") ? + (({1'b0, xCounter} >= 2) & ({1'b0, xCounter} < C_HORZ_NUM_PIXELS+2) & ({1'b0, yCounter} < C_VERT_NUM_PIXELS)) : + (({1'b0, xCounter} >= 0) & ({1'b0, xCounter} < C_HORZ_NUM_PIXELS+2) & ({1'b0, yCounter} < C_VERT_NUM_PIXELS)); + + always @(pixel_colour or on_screen) + begin + VGA_R <= 'b0; + VGA_G <= 'b0; + VGA_B <= 'b0; + if (MONOCHROME == "FALSE") + begin + for (index = 10-BITS_PER_COLOUR_CHANNEL; index >= 0; index = index - BITS_PER_COLOUR_CHANNEL) + begin + for (sub_index = BITS_PER_COLOUR_CHANNEL - 1; sub_index >= 0; sub_index = sub_index - 1) + begin + VGA_R[sub_index+index] <= on_screen & pixel_colour[sub_index + BITS_PER_COLOUR_CHANNEL*2]; + VGA_G[sub_index+index] <= on_screen & pixel_colour[sub_index + BITS_PER_COLOUR_CHANNEL]; + VGA_B[sub_index+index] <= on_screen & pixel_colour[sub_index]; + end + end + end + else + begin + for (index = 0; index < 10; index = index + 1) + begin + VGA_R[index] <= on_screen & pixel_colour[0:0]; + VGA_G[index] <= on_screen & pixel_colour[0:0]; + VGA_B[index] <= on_screen & pixel_colour[0:0]; + end + end + end + +endmodule |