前言

本部分实验基于电子森林小脚丫开发板的数电入门教程实验。实验链接：step-mxo2入门教程电子森林] (eetree.cn)

其中代码是博主学习后根据自己思路自己敲的，并非直接复制，且仅供学习交流使用，侵删。

lattice 环境配置在此不再赘述~

按键LED

module LED (key,sw,led);
	input [3:0] key;
	input [3:0] sw;
	output [7:0] led;
	
	assign led={key, sw};
	
endmodule

1688844371133

三色LED

开发板上的一个三色LED灯，通过赋3位值来决定亮哪个颜色。用三个按键控制 easy

module LED (key,led);
	input [2:0] key;
	output [2:0] led;
	
	assign led={key};
	
endmodule

3-8译码器

三个按键输出8个状态。主要是练习 always case 的使用。

module LED (key,led);
	input [2:0] key;
	output [7:0] led;
	reg [7:0] led;
	always @(key)
	begin
		case(key)
			3'b000:led=8'b11111110;
			3'b001:led=8'b11111101;
			3'b010:led=8'b11111011;
			3'b011:led=8'b11110111;
			3'b100:led=8'b11101111;
			3'b101:led=8'b11011111;
			3'b110:led=8'b10111111;
			3'b111:led=8'b01111111;
			default:;		
		endcase
	end
			
	
endmodule

数码管显示

两个数码管，每个需要9位输入，其中4位是数据输入，可以输入10种状态对应0-9.

我们通过按键和拨码开关传入数据。led 设置我想就记住就行先。

module SEG_LED (key,sw,seg_led_1,seg_led_2);
	input [3:0] key;
	input  [3:0] sw;
	output [8:0] seg_led_1;
	output [8:0] seg_led_2;
	
	reg [8:0] seg [9:0];
	
	initial
	begin
		seg[0]=9'h3f;
		seg[1]=9'h06;
		seg[2]=9'h5b;
		seg[3]=9'h4f;
		seg[4]=9'h66;
		seg[5]=9'h6d;
		seg[6]=9'h7d;
		seg[7]=9'h07;
		seg[8]=9'h7f;
		seg[9]=9'h6f;
	end
	
	assign seg_led_1=seg[key];
	assign seg_led_2=seg[sw];
			
	
endmodule

时钟分频

算法

偶数倍频：光看上升或者下降沿个数就行，0_{N/2-1时翻转，N/2}N-1时再翻转。

奇数倍频：形如下图。

如图为5分频，输入5个周期输出1个周期。所以每2.5个周期一翻转，比如从上升沿开始，再经过两个上升沿，后一个下降沿后翻转。

这样就没法只通过上升或者下降沿去判断了，因为结尾是半个上升/下降沿。不过通过纯上升，下降沿的波形（上升沿比下降沿多一个周期）我们可以发现，两者and操作得到的就是我们想要的结果。

实现

module div(clk_in, rst_n ,clk_out);
	input clk_in,rst_n;
	output clk_out;
	
	parameter WIDTH=3;
	parameter N=5;
	
	reg [WIDTH-1:0] cnt_p, cnt_n;
	reg clk_p, clk_n;
	
	always @ (posedge clk_in or negedge rst_n)
		begin
			if(!rst_n)cnt_p<=0;
			else if(cnt_p==(N-1))
				cnt_p<=0;
			else 
				cnt_p<=cnt_p+1;
		end

	always @ (negedge clk_in or negedge rst_n)
		begin
			if(!rst_n)cnt_n<=0;
			else if(cnt_n==(N-1))
				cnt_n<=0;
			else 
				cnt_n<=cnt_n+1;
		end
		
	always @ (posedge clk_in or negedge rst_n)
		begin
			if(!rst_n)clk_p<=0;
			else if(cnt_p<(N>>1))
				clk_p<=0;
			else 
				clk_p<=1;
		end
		
	always @ (negedge clk_in or negedge rst_n)
		begin
			if(!rst_n)clk_n<=0;
			else if(cnt_n<(N>>1))
				clk_n<=0;
			else 
				clk_n<=1;
		end
		
	assign clk_out=(N==1)?clk_in:(N[0])?clk_p&clk_n:clk_p;
endmodule

打不开仿真显示 license 错误可能是仿真和 license 版本不对。

1688887214194

1688887262813

流水灯

采用模块的思想。我们把前面的3-8译码器（led）部分和时钟分频部分代码结合起来，然后用一个模块去用他俩，传递输入输出。

module flashled (clk,rst,led);
	input clk,rst;
	output [7:0]led;
	
	reg [2:0] cnt;
	
	wire clk1h;
	
	LED u1 (
		.key(cnt),
		.led(led)
	);
	
	div #(.WIDTH(32),.N(12000000)) u2 (         
        .clk_in(clk),
        .rst_n(rst),
        .clk_out(clk1h)
    );               
	
	always @(posedge clk1h or negedge rst)
		if(!rst)
			cnt<=0;
		else
			cnt<=cnt+1;
endmodule

还有一种简单的 led 赋值法，我们知道 led 形如 1111 1101 也就是8位不断循环来形成流水灯的效果。所以我们只需要让 led 不断循环左移或者右移就行。

led={led[0],led[7:1]};

1688891724885

按键消抖

如果只是一个简单的按下按键翻转LED灯状态，那确实很好写：

module debounce (key,rst,key_pulse);
	input key,rst;
	output key_pulse;
	
	reg key_pulse;
	
	always @(negedge rst or negedge key)
		begin
			if(!rst)
				key_pulse=1;
			else
				key_pulse=~key_pulse;
		end
	
endmodule

选用一个按键作为 rst，一个按键为 led 的输入。

但是经典问题，按下按键和松开的一瞬间按键的电平是不断抖动的并不稳定：

这里以（下降沿触发）为例。解决方案为：检测到第一次下降沿后，先延时>10ms，再检测按键是否仍然处于低电平，如果是说明确实是被按下了，如果不是可能只是一个小抖动。

module debounce (clk,key,rst,key_pulse);
	input key;
	input rst;
	input clk;
	output key_pulse;
	
	reg key_rst_pre;
	reg key_rst;
	
	
	reg [17:0] cnt;
	
	wire key_edge;
	
	always @(posedge clk or negedge rst)
		begin
			if(!rst) begin
				key_rst_pre<=1'b1;
				key_rst<=1'b1;
			end
			else begin
				key_rst<=key;
				key_rst_pre<=key_rst;
			end
		end
		
	assign key_edge=key_rst_pre&~(key_rst);
	reg key_sec_pre,key_sec;
	
	always @(posedge clk or negedge rst)
		begin
			if(!rst)
				cnt<=18'h0;
			else if(key_edge)
				cnt<=18'b0;
			else
				cnt<=cnt+1'h1;
		end
		
	always @(posedge clk or negedge rst)
		begin
			if(!rst)
				key_sec<=1'b1;
			else if(cnt==18'h3ffff)
				key_sec<=key;
		end
		
	always @(posedge clk or negedge rst)
		begin
			if(!rst)
				key_sec_pre<=1'b1;
			else
				key_sec_pre<=key_sec;
		end
		
	assign key_pulse=key_sec_pre&~(key_sec);
	
endmodule

下降沿的时候 key_edge 置1，只有当起始状态上升沿， key_edge 下降后一定时间内没有新的下降沿（无抖动）且此时仍然为下降沿时脉冲信息才为1.

处理脉冲部分很简单，读到 pulse 如果是1就翻转 led，否则保持。

module top (clk,key,led,rst);

	input clk;
	input key;
	input rst;
	output reg led;
	
	wire key_pulse;

	debounce u1 (
		.clk(clk),
		.key(key),
		.rst(rst),
		.key_pulse(key_pulse)
	);
	
	always @ (posedge clk or negedge rst)
		begin
			if(!rst)
				led<=1'b1;
			else if(key_pulse)
				led<=~led;
			else
				led<=led;
		end

endmodule

这里写的时候有一个很有趣的bug，我把cnt计数++部分漏掉了，然后生成引脚图定义的时候 clk key rst 都是 unconnected 的引脚，查了一下说是“编译器认为你这几个输入对输出无影响就自动忽略了”。

计时控制

需求：写一个篮球24s计时软件。要求：

上电后从24开始倒计时到0为止停止。
按下 rst 归位到24.
按下按钮后暂停当前计时，再次按下后继续计时。

主要就是写一个模块用到了时钟分频模块（传入参数设定间隔1s），按键模块（用刚刚用的消抖的）。数码管显示 LED显示都可以在本模块内补全。

写的时候发现一个 always 赋值语法规范：一个变量赋值不要在多个 always 里分别有过赋值，会报错，尽量集中到一个 always 里。

module BasketballBoard (key, clk, rst, seg_led_1,seg_led_2,led);
	input key, clk, rst;
	output [8:0] seg_led_1;
	output [8:0] seg_led_2;
	output reg [7:0] led;

	reg [8:0] seg [9:0];
	
	reg [4:0] SED_LED_H;
	reg [4:0] SED_LED_L;
	wire key_pulse;
	wire clk1h;
	
	reg stop_flag=0;
	reg rst_flag=0;
	
	initial
	begin
		seg[0]=9'h3f;
		seg[1]=9'h06;
		seg[2]=9'h5b;
		seg[3]=9'h4f;
		seg[4]=9'h66;
		seg[5]=9'h6d;
		seg[6]=9'h7d;
		seg[7]=9'h07;
		seg[8]=9'h7f;
		seg[9]=9'h6f;
	end
	
	always @ (posedge key_pulse)
		if(rst) 
			rst_flag<=~rst_flag;
			
		
	debounce u1 (
			.clk(clk),
			.rst(rst),
			.key(key),
			.key_pulse(key_pulse)
		);
		
		
	div #(.WIDTH(32),.N(12000000)) u2 ( 
		.clk_in(clk),
		.rst_n(rst),      
		.clk_out(clk1h)
		);
		
	always @ (posedge clk1h or negedge rst)
		begin
			if(!rst)
				begin
					SED_LED_H<=4'd2;
					SED_LED_L<=4'd4;
					stop_flag<=0;
				end
			else if((!rst_flag)&(!stop_flag))
				begin
					led<=8'b11111111;
					if(SED_LED_L)
						SED_LED_L<=SED_LED_L-4'd1;
					else if(SED_LED_H) begin
							SED_LED_L<=4'd9;
							SED_LED_H<=SED_LED_H-4'd1;
						end
					if((!SED_LED_H)&(!SED_LED_L))
						stop_flag<=1;
				end
			else
				led<=8'b00000000;
		end
		
	assign seg_led_1=seg[SED_LED_H];
	assign seg_led_2=seg[SED_LED_L];

endmodule

led seg key rst clk 这些都是和前面采取类似的引脚设置。再加上前面的 div 模块和 key 模块即可。

呈现效果：计时结束和按下暂停键时 LED 灯会全亮来代表暂停时钟。

LED 流水灯

PWM 原理。随着时间推移改变占空比来呈现出不同亮度的 LED。

1688927302381

比如每个周期长度 100，第一个周期设定高电平0 低电平100，第二个周期设定高电平10 低电平90，第三个周期设定高电平20 低电平80……

也就是说我们需要两个计时器，第一个就是老老实实的记录一个又一个周期，0~Period-1.

第二个计时器一方面，在第一个计时器结束一个周期的时候改变一下自己的占空比，比如上例每个周期结束高电平部分+10.

另一方面，第二个计时器和第一个计时器作比较。比如当前第二个计时器是20也就是20高电平 80低电平，那么计时器1<计时器2的时候设置为高电平，计时器1>计时器2的时候设置为低电平。

module WaterLED(clk,rst,led);
	input clk, rst;
	output led;
	reg [13:0] cnt1;
	reg [13:0] cnt2;
	
	parameter CNT_NUM=2400;
	reg flag=0;
	
	always @ (posedge clk or negedge rst)
		begin
			if(!rst)
				cnt1<=13'b0;
			else if(cnt1==CNT_NUM-1) begin
					cnt1<=13'b0;
					if(flag==0)
						if(cnt2>=CNT_NUM) begin
								flag<=1'b1;
							end
						else cnt2<=cnt2+13'b1;
					else if(flag==1)
						if(cnt2<=0) begin
								flag<=1'b0;
							end
						else cnt2<=cnt2-13'b1;
				end
			else cnt1<=cnt1+13'b1;
		end
		
	
	assign led=cnt1<cnt2?1:0;
endmodule

代码没啥难的。

交通信号灯

两个三色模块各亮各的，表示主路和支路的红绿灯信号。

主路：15绿，3黄，10红（单位：秒）。

支路：7绿，3黄，18红。

概念：状态机，一种抽象模型。对象有状态（state，比如此例中两个红绿灯的三种状态），事件（event，外界施加的，比如我让计数–，或者切换状态颜色），行为（action，交通灯按 event 自己执行的动作，比如切颜色），切换状态（transition，比如红灯绿灯黄灯之间三种状态）。

一开始觉得很容易写。就是两个数组存储主路支路状态表嘛。

module TrafficLED (clk,rst,LED_1,LED_2);
	input clk,rst;
	output reg [2:0] LED_1;
	output reg [2:0] LED_2;
	
	reg [4:0] state_1 [2:0];
	reg [4:0] state_2 [2:0];
	reg [2:0] color_state [2:0];
	
	reg [2:0] cur_state_1;
	reg [2:0] cur_state_2;
	reg [4:0] cur_time_1;
	reg	[4:0] cur_time_2;
	
	wire clk1h;
	
	initial begin
		state_1[0]=5'd14;
		state_1[1]=5'd2;
		state_1[2]=5'd9;
		state_2[0]=5'd6;
		state_2[1]=5'd2;
		state_2[2]=5'd17;
		color_state[0]=3'b101;
		color_state[1]=3'b100;
		color_state[2]=3'b110;
		cur_time_1=5'd14;
		cur_time_2=5'd6;
	end
	
	div #(.WIDTH(32),.N(12000000)) u2 (         
        .clk_in(clk),
        .rst_n(rst),
        .clk_out(clk1h)
    );
	
	always @ (posedge clk1h or negedge rst) begin
			if(!rst) begin
					cur_state_1<=0;
					cur_state_2<=0;
					cur_time_1<=5'd14;
					cur_time_2<=5'd6;
					LED_1<=color_state[cur_state_1];
					LED_2<=color_state[cur_state_2];
				end
			else begin
					if(cur_time_1)cur_time_1<=cur_time_1-5'b1;
					else begin
							if(cur_state_1<2)cur_state_1<=(cur_state_1+1);
							else cur_state_1<=0;
							cur_time_1<=state_1[cur_state_1+1];
						end
					if(cur_time_2)cur_time_2<=cur_time_2-5'b1;
					else begin
							if(cur_state_2<2)cur_state_2<=(cur_state_2+1);
							else cur_state_2<=0;
							cur_time_2<=state_2[cur_state_2+1];
							
						end
					LED_1<=color_state[cur_state_1];
					LED_2<=color_state[cur_state_2];
				end
		end
	
endmodule

有两个注意的地方，都是和 fpga 非阻塞赋值相关的。

之前知道 always 里如果用 <= 赋值，所有变量是结束 always 的时候同时赋值的。第一个错误写法是这么写的：

if(cur_time_1)cur_time_1<=cur_time_1-5'b1;
else begin
        if(cur_state_1<2)cur_state_1<=(cur_state_1+1);
        else cur_state_1<=0;
    	cur_time_1<=state_1[cur_state_1];//这里有区别
    end
if(cur_time_2)cur_time_2<=cur_time_2-5'b1;
else begin
        if(cur_state_2<2)cur_state_2<=(cur_state_2+1);
        else cur_state_2<=0;
    	cur_time_2<=state_2[cur_state_2];//这里有区别
    end
LED_1<=color_state[cur_state_1];
LED_2<=color_state[cur_state_2];

因为我想的是，cur_state+1后切换状态为当前cur_state的状态，也就是已经+1过后的状态。

实际不是这么回事，实际上他俩指令是同时执行的，也就是说state[cur_state]还是刚才没+1的状态。

所以我改成 state[cur_state+1] 了。

第二个错误如下：

if(cur_time_1)cur_time_1<=cur_time_1-5'b1;
else begin
        cur_state_1<=(cur_state_1+1);//这里有区别
    	if(cur_state_1==3)cur_state_1<=0;//这里有区别
    	cur_time_1<=state_1[cur_state_1+1];
    end
if(cur_time_2)cur_time_2<=cur_time_2-5'b1;
else begin
    	cur_state_2<=(cur_state_2+1);//这里有区别
    	if(cur_state_2==3)cur_state_2<=0;//这里有区别
    	cur_time_2<=state_2[cur_state_2+1];
    end
LED_1<=color_state[cur_state_1];
LED_2<=color_state[cur_state_2];

想的也是顺序执行，先+1判断是否超出了（0,1,2）的数组范围，如果超出了就归0.

但是 LED 赋值和 cur_state+1 是同时执行的，也就是有1s我的cur_state是3，LED也尝试获取数组3下标的状态。

所以干脆赋值的时候就：如果为2，直接归0，否则++。这样就不用再一步判断了。