12.31信号位宽转换(整数,非整数),时钟分频(奇数,偶数,任意小数,占空比),自动售货机(1,2),游戏机

非整数倍数据位宽转换8to12

所谓非整数倍,就是利用一个cnt去周期性决定寄存器里怎么输出,这个cnt的值,是最小公倍数

寄存器就正常的寄存,怎么输入怎么寄存 

`timescale 1ns/1ns

module width_8to12(
	input 				   clk 		,   
	input 			      rst_n		,
	input				      valid_in	,
	input	[7:0]			   data_in	,
 
 	output  reg			   valid_out,
	output  reg [11:0]   data_out
);
reg[7:0]data_lock;
reg[1:0]valid_cnt;
always@(posedge clk,negedge rst_n)begin
	if(!rst_n)
		data_lock<=0;
	else if(valid_in)
		data_lock<=data_in;
end
always@(posedge clk,negedge rst_n)begin
	if(!rst_n)
		valid_cnt<=0;
	else if(valid_in)begin
		if(valid_cnt==2'd2)
			valid_cnt<=0;
		else
			valid_cnt<=valid_cnt+1;
	end
end
always@(posedge clk,negedge rst_n)begin
	if(!rst_n)
		valid_out<=0;
	else if(valid_in&&valid_cnt==1)
		valid_out<=1;
	else if(valid_in&&valid_cnt==2)
		valid_out<=1;
	else
		valid_out<=0;
end
always@(posedge clk,negedge rst_n)begin
	if(!rst_n)
		data_out<=0;
	else if(valid_in&&valid_cnt==1)
		data_out<={data_lock,data_in[7:4]};
	else if(valid_in&&valid_cnt==2)
		data_out<={data_lock[3:0],data_in};
end
endmodule

为什么不需要2个8bit的寄存器进行数据缓存:

根据时序图, data_out是在两个数据输入之后的下一个时钟周期产生输出,如果采用两个寄存器缓存两个数据,那么第二个数据还没缓存进寄存器后就要输出数据,这样不能实现满足时序要求的数据输出。

根据时序图,数据是在第二个数据到来之后输出,当仅有一个数据到来时,不产生输出,所以内部设计一个计数器(valid_cnt),用来指示数据接收状态。当检测到valid_in拉高时,valid_cnt加1,valid_cnt在0-2之间循环,valid_cnt复位值是0。当valid_cnt是1或2,且valid_in为高时,输出数据,valid_out拉高。

当valid_cnt==1且valid_in为高时,data_out <= {data_lock, data_in[7:4]};当valid_cnt==2且valid_in为高时,data_out <= {data_lock[3:0], data_in}。

就是说,复位的时候,寄存器里一个也没有,所以就不能输出,然后存了一个后,就是1,再来就可以输出,这时输出,就输出存的8个以及新输入的前4个,并且进到2,表示此时寄存器里存的是第二个输入的,而且前半个已经输出过了,该输出后四个,所以此时要输出,就是输出寄存器的后四个以及新输入的全部,这时候寄存器内部实际上也就相当于空了

也就是说valid_cnt决定输出信号,怎么处理寄存器里的信号

电路图

12.31信号位宽转换(整数,非整数),时钟分频(奇数,偶数,任意小数,占空比),自动售货机(1,2),游戏机_第1张图片

12.31信号位宽转换(整数,非整数),时钟分频(奇数,偶数,任意小数,占空比),自动售货机(1,2),游戏机_第2张图片 

12.31信号位宽转换(整数,非整数),时钟分频(奇数,偶数,任意小数,占空比),自动售货机(1,2),游戏机_第3张图片 

是时序逻辑就是要用触发器,<=最直接的就是D触发器  

 整数倍数据位宽转换8to16

`timescale 1ns/1ns

module width_8to16(
	input 				   clk 		,   
	input 				   rst_n		,
	input				      valid_in	,
	input	   [7:0]		   data_in	,
 
 	output	reg			valid_out,
	output   reg [15:0]	data_out
);
reg[0:0]cnt;
reg[7:0]ram;
always@(posedge clk,negedge rst_n)begin
	if(!rst_n)
		cnt<=0;
	else if(valid_in)
		cnt<=(cnt)?0:1;
	else 
		cnt<=cnt;
end
always@(posedge clk,negedge rst_n)begin
	if(!rst_n)
		ram<=0;
	else if(valid_in)
		ram<=data_in; 
	else
		ram<=ram;
end
always@(posedge clk,negedge rst_n)begin
	if(!rst_n)begin
		data_out<=0;
		valid_out<=0;
	end
	else if(cnt&&valid_in)begin
		data_out<={ram,data_in};
		valid_out<=1;
	end
	else begin
		data_out<=data_out;
		valid_out<=0;
	end
end
endmodule

注意有if情况遗漏时,自动生成锁存器锁存之前的状态

电路图

QN代表反态,即取反

空线代表不利用相应的信号,即不做后续的输出 

简单的逻辑就是生成一个简单的D触发器 

 

12.31信号位宽转换(整数,非整数),时钟分频(奇数,偶数,任意小数,占空比),自动售货机(1,2),游戏机_第4张图片 

这里的D信号,就是控制触发器现态Q的信号,做一些处理,就是二路选择器,然后上面是一个与门;上面的没有是因为锁存的是8位的信号,不是0或1 

 时钟分频(偶数

`timescale 1ns/1ns

module even_div
    (
    input     wire rst ,
    input     wire clk_in,
    output    wire clk_out2,
    output    wire clk_out4,
    output    wire clk_out8
    );
//*************code***********//
reg clk2,clk4,clk8;
always@(posedge clk_in,negedge rst)begin
    if(!rst)
        clk2<=0;
    else
        clk2<=~clk2;
end
always@(posedge clk2,negedge rst)begin
    if(!rst)
        clk4<=0;
    else
        clk4<=~clk4;
end
always@(posedge clk4,negedge rst)begin
    if(!rst)
        clk8<=0;
    else
        clk8<=~clk8;
end
assign clk_out8=clk8;
assign clk_out4=clk4;
assign clk_out2=clk2;
//*************code***********//
endmodule

12.31信号位宽转换(整数,非整数),时钟分频(奇数,偶数,任意小数,占空比),自动售货机(1,2),游戏机_第5张图片

D触发器12.31信号位宽转换(整数,非整数),时钟分频(奇数,偶数,任意小数,占空比),自动售货机(1,2),游戏机_第6张图片

D触发器构建电路图,就是<=右边的为输入的D信号,左边的就是输出的Q现态信号

 D触发器接口,有控制触发器触发的时钟信号,以及D信号,就是等式右侧的信号,输出的就是转换后的信号

占空比50%的奇数分频

`timescale 1ns/1ns


module odo_div_or
  #(parameter N = 7)
   (
    input    wire  rst ,
    input    wire  clk_in,
    output   wire  clk_out7
    );



   reg [3:0]            cnt ;
   always @(posedge clk_in or negedge rst) begin
      if (!rst) begin
         cnt    <= 'b0 ;
      end
      else if (cnt == N-1) begin
         cnt    <= 'b0 ;
      end
      else begin
         cnt    <= cnt + 1'b1 ;
      end
   end

   reg                  clkp ;
   always @(posedge clk_in or negedge rst) begin
      if (!rst) begin
         clkp <= 1'b0 ;
      end
      else if (cnt == (N>>1)) begin 
        clkp <= 1 ;
      end
      else if (cnt == N-1) begin 
        clkp <= 0 ;
      end
   end
  

   reg                  clkn ;
   always @(negedge clk_in or negedge rst) begin
      if (!rst) begin
         clkn <= 1'b0 ;
      end
      else if (cnt == (N>>1) ) begin 
        clkn <= 1 ;
      end
      else if (cnt == N-1) begin 
        clkn <= 0 ;
      end
   end


   assign clk_out7 = clkp | clkn ;


endmodule

对于奇数分频电路,主要难点在于50%占空比的实现。单触发沿在奇数分频中是没有办法实现50%占空比的,因此需要考虑使用双边沿加组合逻辑实现50%占空比 

clkout7的翻转第一次是在上升沿,第二次是在下降沿。12.31信号位宽转换(整数,非整数),时钟分频(奇数,偶数,任意小数,占空比),自动售货机(1,2),游戏机_第7张图片

任意小数分频

请设计一个可以实现任意小数分频的时钟分频器,比如说8.7分频的时钟信号

注意rst为低电平复位

提示:

其实本质上是一个简单的数学问题,即如何使用最小公倍数得到时钟周期的分别频比。

设小数为nn,此处以8.7倍分频的时钟周期为例。

首先,由于不能在硬件上进行小数的运算(比如2.1个时钟这种是不现实的,也不存在3.3个寄存器),小数分频不能做到分频后每个时钟周期都是源时钟的nn倍,也无法实现占空比为1/2,因此,考虑小数分频,其实现方式应当为53个clkout时钟周期是10个clkin时钟周期的8.7倍。

12.31信号位宽转换(整数,非整数),时钟分频(奇数,偶数,任意小数,占空比),自动售货机(1,2),游戏机_第8张图片

其实和非整数倍数据转位宽差不多,

非整数倍数据转位宽,是用一个计数器,去记录当前是输出到第几个阶段了

用一个寄存器,然后记录当前输入的信号,最后就依据计数器的信号,做出相应的输出,结合此时输出的信号;

不同的点在于,非整数倍的数据位宽转换,每个时钟周期内都会输出信号

而小数分频器,是一定时间内为1,一定时间内为0

分频器,是把信号频率变慢,原来10秒内跳10次,现在只跳1次12.31信号位宽转换(整数,非整数),时钟分频(奇数,偶数,任意小数,占空比),自动售货机(1,2),游戏机_第9张图片

思路就是逼近模拟,在大的周期上表现的是小数分频,小的周期里就用奇数分频以及偶数分频逼近,然后一个计数器去记录大的周期,一个计数器就是实现每个小的周期上的分频;那个大的周期上的,决定此时小的周期上是用什么分频器,是奇数还是偶数;然后用一个FLAG标志,去记录当前是用奇数分频器还是偶数分频器,这个FLAG在中间某一点以及整个大周期结束时去进行更换,中间某一点通过计算得到 

`timescale 1ns/1ns

module div_M_N(
     input  wire clk_in,
     input  wire rst,
     output wire clk_out
);
    parameter M_N = 8'd87; 
    parameter c89 = 8'd24;  // 8/9时钟切换点
    parameter div_e = 5'd8; //偶数周期
    parameter div_o = 5'd9; //奇数周期
//*************code***********//
    reg [3:0] clk_cnt;
    reg [6:0] cyc_cnt;
    reg div_flag;
    reg clk_out_r;
    
    always@(posedge clk_in or negedge rst) begin
        if(~rst)
            clk_cnt <= 0;
        else if(~div_flag)
            clk_cnt <= clk_cnt==(div_e-1)? 0: clk_cnt+1;
        else
            clk_cnt <= clk_cnt==(div_o-1)? 0: clk_cnt+1;
    end
    
    always@(posedge clk_in or negedge rst) begin
        if(~rst)
            cyc_cnt <= 0;
        else
            cyc_cnt <= cyc_cnt==(M_N-1)? 0: cyc_cnt+1;
    end
    
    always@(posedge clk_in or negedge rst) begin
        if(~rst)
            div_flag <= 0;
        else
            div_flag <= cyc_cnt==(M_N-1)||cyc_cnt==(c89-1)? ~div_flag: div_flag;
    end
    
    always@(posedge clk_in or negedge rst) begin
        if(~rst)
            clk_out_r <= 0;
        else if(~div_flag)
            clk_out_r <= clk_cnt<=((div_e>>2)+1);
        else
            clk_out_r <= clk_cnt<=((div_o>>2)+1);
    end
    
    assign clk_out = clk_out_r;
//*************code***********//
endmodule

 在电路图当中,画触发器,就是先看时钟信号是什么,接上去,然后看复位信号是什么,接上去;再就是对应D信号,选触发器,对于<=,就是用D触发器,左侧就是输出的Q现态信号,右侧就是输入的D信号,遇到三目表达式或者else if 选择,就是选择器,选择出一个信号接到D信号上

无占空比要去的奇数分频

所谓占空比,就是在一个周期内0和1所占的比例。

以小数分频器上题为例,要实现小数分频器,在大周期里,flag在周期末以及中间某一点去更新,中间某一点就决定了什么时候反转,也决定了flag的占空比

同理在分频器中,输出分频信号什么时候反转,就是对应中间某一点,但是一定会在周期末进行反转,即cnt==分频数时。

选取中间点时,占空比是百分之五十

 

`timescale 1ns/1ns

module odd_div (    
    input     wire rst ,
    input     wire clk_in,
    output    wire clk_out5
);
//*************code***********//
reg[2:0]cnt;
reg clko;
always@(posedge clk_in,negedge rst)begin
    if(!rst)
        cnt<=0;
    else
        cnt<=cnt==4?0:cnt+1;
end
always@(posedge clk_in,negedge rst)begin
    if(!rst)
        clko<=0;
    else
        clko<=cnt<=1;
end
assign clk_out5=clko;
//*************code***********//
endmodule

自动贩售机1

状态机

`timescale 1ns/1ns
module seller1(
	input wire clk  ,
	input wire rst  ,
	input wire d1 ,
	input wire d2 ,
	input wire d3 ,
	
	output reg out1,
	output reg [1:0]out2
);
parameter s0=0,s1=1,s2=2,s3=3,s4=4,s5=5,s6=6;
reg[2:0]cs;
reg[2:0]ns;
wire[2:0]is;
assign is={d1,d2,d3};//将输入的控制信号并在一起
always@(posedge clk,negedge rst)begin
	if(!rst)
		cs<=s0;
	else
		cs<=ns;
end

always@(*)begin
	case(cs)
		s0:begin
			case(is)
				3'b100:ns=s1;
				3'b010:ns=s2;
				3'b001:ns=s4;
				default:ns=ns;
			endcase
		end
		s1:begin
			case(is)
				3'b100:ns=s2;
				3'b010:ns=s3;
				3'b001:ns=s5;
				default:ns=ns;
			endcase
		end		
		s2:begin
			case(is)
				3'b100:ns=s3;
				3'b010:ns=s4;
				3'b001:ns=s6;
				default:ns=ns;
			endcase
		end
		default:begin
			ns=s0;
		end
	endcase
end

always@(posedge clk,negedge rst)begin
	if(!rst)begin
		out1<=0;
		out2<=0;
	end
	else begin
		case(ns)
			s3:begin 
				out1<=1;
				out2<=0;
			end
			s4:begin
				out1<=1;
				out2<=1;
			end
			s5:begin
				out1<=1;
				out2<=2;
			end
			s6:begin
				out1<=1;
				out2<=3;
			end
			default:begin
				out1<=0;
				out2<=0;
			end
		endcase
	end
end
endmodule

自动贩售机2

sel为0买第一种饮料,为1买第二种,s3时就可以买了,不过只能买第一种

一旦能买,次态就只能是0,表示这一次付款的终止,然后找零在输出去执行

输出,只能是MEALY机,即输出与当前状态以及输入信号有关,不能是MOORE机,否则状态太多

是MEALY机就是输出一方面取决于现态,一方面取决于输入信号,这里就是SEL信号,或者可以写一个二段式,

用MOORE机的话,判断输出用次态,则不能确定到底是要买什么,需要SEL以及现态共同确定一个状态才行

`timescale 1ns/1ns

module seller2(
	input wire clk  ,
	input wire rst  ,
	input wire d1 ,
	input wire d2 ,
	input wire sel ,
	
	output reg out1,
	output reg out2,
	output reg out3
);
//*************code***********//

    parameter S0=0, S0_5=1, S1=2, S1_5=3, S2=4, S2_5=5, S3=6;
    reg[2:0] state, nstate;
    
    always@(posedge clk or negedge rst) begin
        if(~rst)
            state <= 0;
        else
            state <= nstate;
    end
    
    always@(*) begin
        case(state)
            S0     : nstate = d1? S0_5:
                              d2? S1:
                              nstate;
            S0_5   : nstate = d1? S1:
                              d2? S1_5:
                              nstate;
            S1     : nstate = d1? S1_5:
                              d2? S2:
                              nstate;
            S1_5   : nstate = ~sel? S0:
                              d1? S2:
                              d2? S2_5:
                              nstate;
            S2     : nstate = ~sel? S0:
                              d1? S2_5:
                              d2? S3:
                              nstate;
            default: nstate = S0;
        endcase
    end
    
    always@(*) begin
        if(~rst) begin
            {out1, out2, out3} = 3'b000;
        end
        else begin
            case(state)
                S0, S0_5, S1: {out1, out2, out3} = 0;
                S1_5        : {out1, out2, out3} = ~sel? 3'b100: 3'b000;
                S2          : {out1, out2, out3} = ~sel? 3'b101: 3'b000;
                S2_5        : {out1, out2, out3} = ~sel? 3'b101: 3'b010;
                S3          : {out1, out2, out3} = ~sel? 3'b101: 3'b011;
                default     : {out1, out2, out3} = 3'b000;
            endcase
        end
    end
//*************code***********//
endmodule

游戏机计费程序

`timescale 1ns/1ns

module game_count
(
    input rst_n, //异位复位信号,低电平有效
    input clk, 	//时钟信号
    input [9:0]money,
    input set,
    input boost,
    output reg[9:0]remain,
    output reg yellow,
    output reg red
);
    always@(posedge clk or negedge rst_n) begin
        if(~rst_n) begin
            yellow <= 0;
            red    <= 0;
        end
        else begin
            yellow <= remain<10&&remain;
            red    <= boost? remain<2: remain<1;
        end
    end
    
    always@(posedge clk or negedge rst_n) begin
        if(~rst_n) 
            remain <= 0;
        else if(boost)
            remain <= set     ? remain+money:
                      remain<2? remain: 
                      remain-2;
        else
            remain <= set     ? remain+money:
                      remain<1? remain: 
                      remain-1;
    end
endmodule
`timescale 1ns/1ns

module game_count
    (
		input rst_n, //异位复位信号,低电平有效
        input clk, 	//时钟信号
        input [9:0]money,
        input set,
		input boost,
		output reg[9:0]remain,
		output reg yellow,
		output reg red
    );
    
    always@(posedge clk or negedge rst_n)begin
        if(~rst_n)
            remain <= 0;
        else begin
            if(boost==0)
                remain <= set==1? remain+money: remain-1;
            else if(boost==1)
                remain <= set==1? remain+money: remain-2;
        end
    end
    
    always@(posedge clk or negedge rst_n)begin
        if(~rst_n)begin
            yellow <= 0;
            red <= 0;
        end
        else begin
            if(remain < 1)begin
                yellow <= 0;
                red <= 1;
            end
            else if(remain < 10)begin
                yellow <= 1;
                red <= 0;
            end
            else begin
                yellow <= 0;
                red <= 0;
            end
        end
    end

endmodule

你可能感兴趣的:(数电,fpga开发)