It’s Xiaobai’s first time writing a blog, so I’m a little nervous and excited, haha.

Since I didn’t study for too long and it was a big homework for an elective course, the time was limited. The program may be written in a simple and naive way, and some functions were thought of but not implemented. Please give me your criticisms and corrections.

I have made some arrangements and modifications to the source program, but since I don’t have a development board at hand, I have no way to verify it. There may be some errors in the uploaded files. I hope you can correct me. If you want the program but have no points or want the original program, you can send me a private message and I will send it to you as soon as I see it.

The main function of this program is to implement simple Tetris. The stacking range of the blocks is a matrix of 18*10. The blocks fall one square every 0.25s. The blocks can be moved left and right through buttons or switches. If a certain row of blocks is full, the corresponding row will disappear. , the blocks above are dropped and completed, and the blocks are piled to the highest level, the game is over, and you can control the game to restart through the reset button (since there is only one day, the program was written in a hurry, and some of the functions I thought of were not implemented. I will write about it at the end. I will also explain the ideas and problems in the program).

Let’s get down to business…

The first is the port declaration. CLK is the 50MHZ clock on the development board. RST is used as the reset signal to restart the game. DOUT is used to output the RGB signal of VGA. , is the row and column synchronization signal (controlling the number of frames and resolution). left and right are used Move left and right on the control block.

module VGA( CLK, RST, DIN, DOUT, VGA_HSYNC, VGA_VSYNC, left, right);

In the variable declaration, in addition to the declaration of the port, there are also definitions of 18 variables with a length of 10, that is, a matrix composed of these variables is used to store whether a certain position is occupied (yes, the square can only be 18*10) move within an area). In addition, there is a variable over used to record whether the game is over, and a variable n used to record the falling graphics (because this program is relatively simple, the length of n is only 2, and there are three graphics in total). The variable temp records the left and right movement of the block, and also facilitates the judgment and change of the corresponding position of the matrix. The variables x and y record the coordinates of the falling block and are used to limit the display area. clk_4 is the 4HZ clock, used to control the falling block. h_cnt, v_cnt are variables used for VGA scanning.

input CLK;
input RST;
input left;
input right;
output [2:0] DOUT;
output VGA_HSYNC;
output VGA_VSYNC;
reg over;
reg [10:1]y1=10'b0000000000;
reg [10:1]y2=10'b0000000000;
reg [10:1]y3=10'b0000000000;
reg [10:1]y4=10'b0000000000;
reg [10:1]y5=10'b0000000000;
reg [10:1]y6=10'b0000000000;
reg [10:1]y7=10'b0000000000;
reg [10:1]y8=10'b0000000000;
reg [10:1]y9=10'b0000000000;
reg [10:1]y10=10'b0000000000;
reg [10:1]y11=10'b0000000000;
reg [10:1]y12=10'b0000000000;
reg [10:1]y13=10'b0000000000;
reg [10:1]y14=10'b0000000000;
reg [10:1]y15=10'b0000000000;
reg [10:1]y16=10'b0000000000;
reg [10:1]y17=10'b0000000000;
reg [10:1]y18=10'b0000000000;
reg [1:0]n;
reg [2:0] RGB;
reg [9:0] h_cnt;
reg [9:0] v_cnt;
reg VGA_CLK;
reg [8:1]temp=6;
wire clk_4;
reg [32:1]x=390;				
reg [32:1]y=80;
wire data_valid;

The frequency division part is relatively simple, so I won’t go into details here.

always @ (posedge CLK or posedge RST)
begin
	if(RST) VGA_CLK <= 1'b0;
	else VGA_CLK <= ~VGA_CLK;						
end

fd_4 fd_4(
	.clk_50m(CLK),
	.clk_4(clk_4)
);

VGA initialization. Here, all content outside the range is dyed black through the ternary operator, and pixels and frames are specified. VGA scans line by line. After scanning one line, start scanning the next line. After scanning all, start from the beginning. (There are many online examples and explanations about the VGA display part. I only understand it to this level. If there are any mistakes, please let me know. Point it out. For details, you can refer to this guy’s article, which I feel is very powerful). By the way, I also added RST here, but I personally feel that it is not very good to write it here.

always @(posedge VGA_CLK or posedge RST)
begin
	if(RST) 
		begin
		y1<=10'b0000000000;
		y2<=10'b0000000000;
		y3<=10'b0000000000;
		y4<=10'b0000000000;
		y5<=10'b0000000000;
		y6<=10'b0000000000;
		y7<=10'b0000000000;
		y8<=10'b0000000000;
		y9<=10'b0000000000;
		y10<=10'b0000000000;
		y11<=10'b0000000000;
		y12<=10'b0000000000;
		y13<=10'b0000000000;
		y14<=10'b0000000000;
		y15<=10'b0000000000;
		y16<=10'b0000000000;
		y17<=10'b0000000000;
		y18<=10'b0000000000;
		over<=0;	
		end
	else if (h_cnt == 10'd799) h_cnt <= 10'd0;
	else  h_cnt <= h_cnt + 1'b1;
end

always @(posedge VGA_CLK or posedge RST)begin
	if(RST) v_cnt <= 10'd0;
	else if (v_cnt == 10'd520) v_cnt <= 10'd0;
	else if(h_cnt == 10'd799) v_cnt <= v_cnt + 1'b1;
	else v_cnt <= v_cnt;
end

Next is the more critical part, regarding the realization of the whereabouts, graphics, left and right movement and accumulation elimination of the blocks, let me explain slowly (let me tell you in advance that the blocks are limited to a rectangle, and the rectangular width is 300~480. The vertical length is 60~420, and each small square is 20*18 size)…

(1). The whereabouts of the block

The falling block event is triggered by the rising edge of the 4HZ clock. If the top value is 0, that is, y18==0, it means that the game is still progressing normally, the end variable over value is 0, and the variable y is incremented by 20 to achieve a drop of one unit; otherwise, it is y18! =0, indicating that the game is over, and the over value is 1;

if(y18==0)
	begin
	over<=0;
	y<=y+20;
        ......
        end
else
        over<=1;

(2), left and right movement of the block

The square moves left and right through two buttons (the buttons on our school board jittered too much, so I directly replaced them with switches), which are also triggered by the rising edge of the 4HZ clock (in fact, the 8HZ clock can be used here to trigger, and the 8HZ is divided again to get 4HZ. in the whereabouts incident). Shifting to the right corresponds to x+=18, temp+=1; shifting to the left corresponds to x-=18, temp-=1; but it must also be considered that the block cannot be moved outside the scope of the box, and the shape of the block must also be considered (due to the shape of this program Relatively few, you only need to consider additional shapes 2 and the two horizontal squares when moving left and right).

if(right)
	begin	
	if(x>443&&n==2)
		begin
		end
	else if(x<462)			
		begin
			x<=x+18;
			temp300)
		begin
			x<=x-18;
			temp<=temp-1;
		end
	end

(3) Accumulation of blocks

Block stacking mainly determines whether the matrix value corresponding to the grid below the current graphic is 1. If it is 1, it means there are blocks below, then the blocks are stacked, and the blocks above are

The corresponding matrix position value of the block is set to 1, and the block starts falling from the top again; otherwise, the block falls normally.Of course, we also need to consider the issue of block graphics. This program only has three graphics, which are

if to discuss.

if((y=60)&&(y17[temp]==1))
	begin
		y18[temp]<=1;
		y<=60;
		n<=n+1;
	end	

(4) Elimination of blocks

Block elimination is implemented by judging the matrix, and the code should be relatively easy to understand.

if(y1==10'b1111111111)
	begin
		y1<=y2;							
		y2<=y3;
		y3<=y4;
		y4<=y5;
		y5<=y6;
		y6<=y7;
		y7<=y8;
		y8<=y9;
		y9<=y10;
		y10<=y11;
		y11<=y12;
		y12<=y13;
		y13<=y14;
		y14<=y15;
		y15<=y16;
		y16<=y17;
		y17<=y18;
		y18<=10'b0000000000;
	end

(5), block graphics

Block graphics are mainly formed by the value of n. n=0, corresponds to a single square; n=1, corresponds to two vertical squares; n=2, corresponds to two horizontal squares;

n=3, corresponding to a single square.The whereabouts of different shapes are mainly judged and displayed on n in the VGA display, and the shape accumulation is determined by judging n.

How to stack.

else if((y=80)&&(y16[temp]==1))
	begin
		y17[temp]<=1;
		if(n==1)
			begin
				y18[temp]<=1;
			end
		if(n==2)
			begin
				y17[temp+1]<=1;
			end
		y<=60;
		n<=n+1;
	end

	else if((v_cnt>y && v_cntx && h_cnt<x+18) )RGB y-20 && v_cntx && h_cnt<x+18)&&(n==1) )RGB y && v_cnt(x+18) && h_cnt<x+36)&&(n==2))RGB <= 3'd000;

Regarding the VGA display, it actually means calculating the grid, calculating the range, and changing the RGB.I first drew a box, and then used the matrix to correspond to the squares in the box.

Relationship, display the values ​​in the matrix into the box in the form of squares.The falling of the block is realized by displaying x and y (the code above), and the shape is displayed after judging n.

Now (at the request of the teacher, my student number is displayed on the lower right. The word OVER after the end is displayed on the upper right. Since I do not have the font library,

OVER was drawn by myself using dots, it is extremely ugly…please ignore this).

else if(v_cnt>400&&v_cnt300 && h_cnt<318) RGB 400&&v_cnt318 && h_cnt<336) RGB 400&&v_cnt336 && h_cnt<354) RGB 400&&v_cnt354 && h_cnt<372) RGB 400&&v_cnt372 && h_cnt<390) RGB 400&&v_cnt390 && h_cnt<408) RGB 400&&v_cnt408 && h_cnt<426) RGB 400&&v_cnt426 && h_cnt<444) RGB 400&&v_cnt444 && h_cnt<462) RGB 400&&v_cnt462 && h_cnt<480) RGB <= 3'd000;

Only part of the code that has a lot of repetitions has been pasted. I have uploaded the code to the resource (it has not been approved yet) and you can download it yourself.

Next, let me talk about the ideas that I have not implemented and some of my opinions:

(1) If you want to achieve more graphics, you can increase the length of n. Different n corresponds to different graphics; deformation can also be achieved by operating on n.

(2) The program does not judge the block on the right side of the horizontal row of blocks. As a result, there are blocks under the block during the falling process but it will still fall. This can be solved by adding judgment.

(3). The acceleration drop key can be added to the program.

(4). The block only adds the judgment of the block below, which leads to the error that if there is no block below and there are blocks on both sides, the block will move inside. It is necessary to add judgment on both sides of the falling block.

(5) If the deformation or left-right movement is required to be faster than the falling speed, a higher frequency clock can be used for deformation and left-right movement, and then divided by frequency to obtain the falling clock.

(6). The OVER in the upper right corner is really ugly. Please teach me how to use the character set and VGA.

Finally, Xiaobai’s first blog post is not very technical. Please give me your questions, criticisms and corrections. (This editor really tortures me enough. Why does a string of html code appear when I copy the comments? …).

Get the code for free: