【HDLBits刷题笔记】13 Finite State Machines
Fsm1这里需要实现一个简单的摩尔状态机，即输出只与状态有关的状态机。我这里代码看上去比长一点，答案用的case和三目运算符，结果是一样的。moduletop_mo
Fsm1 这里需要实现一个简单的摩尔状态机，即输出只与状态有关的状态机。 我这里代码看上去比长一点，答案用的case和三目运算符，结果是一样的。 module top_module( input clk, input areset, // Asynchronous reset to state B ...
Fsm1
这里需要实现一个简单的摩尔状态机，即输出只与状态有关的状态机。
我这里代码看上去比长一点，答案用的case和三目运算符，结果是一样的。
Fsm1s
和上一题是一样的，只不过换成了同步复位。
//Note the Verilog-1995 module declaration syntax here:moduletop_module(clk,reset,in,out);inputclk;inputreset;//Synchronous reset to state Binputin;outputout;////Fill in state name declarationsregpresent_state,next_state;parameterA=0,B=1;always@(posedgeclk)beginif(reset)beginpresent_state<=B;endelsebegin//State flip-flopspresent_state<=next_state;endendalways@(*)begincase(present_state)A:next_state=in?A:B;B:next_state=in?B:A;endcaseendassignout=(present_state==B);endmodule
Fsm2
这里是一个JK触发器。
moduletop_module(inputclk,inputareset,//Asynchronous reset to OFFinputj,inputk,outputout);//parameterOFF=0,ON=1;regstate,next_state;always@(*)begincase(state)OFF:next_state=j?ON:OFF;ON:next_state=k?OFF:ON;endcaseendalways@(posedgeclk,posedgeareset)begin//State flip-flops with asynchronous resetif(areset)state<=OFF;elsestate<=next_state;end//Output logicassignout=(state==ON);endmodule
Fsm2s
同样是异步改成同步就可以了。
moduletop_module(inputclk,inputreset,//Synchronous reset to OFFinputj,inputk,outputout);//parameterOFF=0,ON=1;regstate,next_state;always@(*)begincase(state)OFF:next_state=j?ON:OFF;ON:next_state=k?OFF:ON;endcaseendalways@(posedgeclk)beginif(reset)state<=OFF;elsestate<=next_state;end//Output logicassignout=(state==ON);endmodule
Fsm3comb
这道题只需要实现状态转换逻辑和输出逻辑，状态转换的时序逻辑不需要实现。
moduletop_module(inputin,input[1:0]state,output[1:0]next_state,outputout);//parameterA=0,B=1,C=2,D=3;//State transition logic: next_state = f(state, in)always@(*)begincase(state)A:next_state=in?B:A;B:next_state=in?B:C;C:next_state=in?D:A;D:next_state=in?B:C;endcaseend//Output logic: out = f(state) for a Moore state machineassignout=(state==D);endmodule
Fsm3onehot
这道题要求使用独热码，即只有一个1的编码。
这里提到了一个概念"derive equations by inspection"，指通过某一个位就可以判断当前状态，例如可以用state[0]判断当前状态是否为A，这样可以简化状态转换逻辑。
moduletop_module(inputin,input[3:0]state,output[3:0]next_state,outputout);//parameterA=0,B=1,C=2,D=3;//State transition logic: Derive an equation for each state flip-flop.assignnext_state[A]=(state[A]&~in)|(state[C]&~in);assignnext_state[B]=(state[A]&in)|(state[B]&in)|(state[D]&in);assignnext_state[C]=(state[B]&~in)|(state[D]&~in);assignnext_state[D]=(state[C]&in);//Output logic:assignout=state[D];endmodule
Fsm3
状态转换逻辑在前面已经实现了，这里只需要实现状态转换寄存器和输出寄存器。
moduletop_module(inputclk,inputin,inputareset,outputout);//reg[1:0]state,next_state;//State transition logicparameterA=0,B=1,C=2,D=3;always@(*)begincase(state)A:next_state=in?B:A;B:next_state=in?B:C;C:next_state=in?D:A;D:next_state=in?B:C;endcaseend//State flip-flops with asynchronous resetalways@(posedgeclkorposedgeareset)beginif(areset)state<=A;elsestate<=next_state;end//Output logicassignout=(state==D);endmodule
Fsm3s
把上一题的异步复位改成同步复位。
moduletop_module(inputclk,inputin,inputreset,outputout);//reg[1:0]state,next_state;//State transition logicparameterA=0,B=1,C=2,D=3;always@(*)begincase(state)A:next_state=in?B:A;B:next_state=in?B:C;C:next_state=in?D:A;D:next_state=in?B:C;endcaseend//State flip-flops with asynchronous resetalways@(posedgeclk)beginif(reset)state<=A;elsestate<=next_state;end//Output logicassignout=(state==D);endmodule
Exams/ece241 2013 q4
又是一道正确率十几的题目。。
fr1、fr2、fr3结果输出可以直接根据题目给的表得出，dfr需要仔细考虑一下，题目的意思是如果之前的水位比现在的水位低，那么就打开dfr，这里的之前并不是指一个时钟的之前，所以当状态不变的时候不需要改变dfr。不过我这种写法就不是严格的摩尔状态机了，因为我在一个时序逻辑中同时使用了state和next_state做对比。
题目给的答案通过六个状态来给出输出，感觉还是有点复杂的。
moduletop_module(inputclk,inputreset,input[3:1]s,outputfr3,outputfr2,outputfr1,outputregdfr);parameterA=0,B=1,C=2,D=3;reg[1:0]state,next_state;always@(posedgeclk)beginif(reset)state<=A;elsestate<=next_state;endalways@(*)beginnext_state=A;case(s)3b111:next_state = D;3b011:next_state=C;3b001:next_state = B;3b000:next_state=A;endcaseendalways@(posedgeclk)beginif(reset)dfr<=1;elseif(next_state<state)dfr<=1;elseif(next_state>state)dfr<=0;endassignfr3=(state==A);assignfr2=(state==A)||(state==B);assignfr1=(state==A)||(state==B)||(state==C);endmodule
Lemmings1
这道题要求用有限状态机描述游戏Lemmings中的角色，角色将在撞到障碍物时改变方向。
题目已经把状态机和代码框架都给出来了，只要补充关键部分即可。
moduletop_module(inputclk,inputareset,//Freshly brainwashed Lemmings walk left.inputbump_left,inputbump_right,outputwalk_left,outputwalk_right);//parameterLEFT=0,RIGHT=1;regstate,next_state;always@(*)begin//State transition logiccase(state)LEFT:next_state=bump_left?RIGHT:LEFT;RIGHT:next_state=bump_right?LEFT:RIGHT;endcaseendalways@(posedgeclk,posedgeareset)begin//State flip-flops with asynchronous resetif(areset)state<=LEFT;elsestate<=next_state;end//Output logicassignwalk_left=(state==LEFT);assignwalk_right=(state==RIGHT);endmodule
Lemmings2
相比上一题多了一个FALL的状态，要求FALL之后还要恢复之前的方向，所以这里增加一个状态是不够的，至少要增加两个状态之后才能使FALL之后恢复原来的状态。
moduletop_module(inputclk,inputareset,//Freshly brainwashed Lemmings walk left.inputbump_left,inputbump_right,inputground,outputwalk_left,outputwalk_right,outputaaah);parameterLEFT=0,RIGHT=1,FALL_L=2,FALL_R=3;reg[1:0]state,next_state;always@(*)begin//State transition logiccase(state)LEFT:next_state=ground?(bump_left?RIGHT:LEFT):FALL_L;RIGHT:next_state=ground?(bump_right?LEFT:RIGHT):FALL_R;FALL_L:next_state=ground?LEFT:FALL_L;FALL_R:next_state=ground?RIGHT:FALL_R;endcaseendalways@(posedgeclk,posedgeareset)begin//State flip-flops with asynchronous resetif(areset)state<=LEFT;elsestate<=next_state;end//Output logicassignwalk_left=(state==LEFT);assignwalk_right=(state==RIGHT);assignaaah=(state==FALL_L)||(state==FALL_R);endmodule
Lemmings3
根据题目给的题目给的状态转换表，还是比较好写的。
直接在上一题代码基础上改的，越改越长。
moduletop_module(inputclk,inputareset,//Freshly brainwashed Lemmings walk left.inputbump_left,inputbump_right,inputground,inputdig,outputwalk_left,outputwalk_right,outputaaah,outputdigging);parameterLEFT=0,RIGHT=1,FALL_L=2,FALL_R=3,DIG_L=4,DIG_R=5;reg[2:0]state,next_state;always@(*)begin//State transition logiccase(state)LEFT:next_state=ground?(dig?DIG_L:(bump_left?RIGHT:LEFT)):FALL_L;RIGHT:next_state=ground?(dig?DIG_R:(bump_right?LEFT:RIGHT)):FALL_R;FALL_L:next_state=ground?LEFT:FALL_L;FALL_R:next_state=ground?RIGHT:FALL_R;DIG_L:next_state=ground?DIG_L:FALL_L;DIG_R:next_state=ground?DIG_R:FALL_R;endcaseendalways@(posedgeclk,posedgeareset)begin//State flip-flops with asynchronous resetif(areset)state<=LEFT;elsestate<=next_state;end//Output logicassignwalk_left=(state==LEFT);assignwalk_right=(state==RIGHT);assignaaah=(state==FALL_L)||(state==FALL_R);assigndigging=(state==DIG_L)||(state==DIG_R);endmodule
Lemmings4
当Lemmings 下落超过20个时钟周期会摔死，注意！Lemmings 不会在半空中摔死，不能以20个周期作为判别条件，而要以到ground时的时钟周期数来计算。
moduletop_module(inputclk,inputareset,//Freshly brainwashed Lemmings walk left.inputbump_left,inputbump_right,inputground,inputdig,outputwalk_left,outputwalk_right,outputaaah,outputdigging);parameterLEFT=0,RIGHT=1,FALL_L=2,FALL_R=3,DIG_L=4,DIG_R=5,SPLAT=6;reg[2:0]state,next_state;reg[7:0]fall_cnt;always@(posedgeclk,posedgeareset)beginif(areset)fall_cnt<=d0;elseif((state == FALL_L)||(state ==FALL_R))fall_cnt<= (fall_cnt>=20)?fall_cnt:fall_cnt+1b1;elsefall_cnt<=d0;endalways@(*)begin//State transition logiccase(state)LEFT:next_state=ground?(dig?DIG_L:(bump_left?RIGHT:LEFT)):FALL_L;RIGHT:next_state=ground?(dig?DIG_R:(bump_right?LEFT:RIGHT)):FALL_R;FALL_L:next_state=ground?((fall_cnt==20)?SPLAT:LEFT):FALL_L;FALL_R:next_state=ground?((fall_cnt==20)?SPLAT:RIGHT):FALL_R;DIG_L:next_state=ground?DIG_L:FALL_L;DIG_R:next_state=ground?DIG_R:FALL_R;SPLAT:next_state=SPLAT;default:next_state=dx;endcaseendalways@(posedgeclk,posedgeareset)begin//State flip-flops with asynchronous resetif(areset)state<=LEFT;elsestate<=next_state;end//Output logicassignwalk_left=(state==LEFT);assignwalk_right=(state==RIGHT);assignaaah=(state==FALL_L)||(state==FALL_R);assigndigging=(state==DIG_L)||(state==DIG_R);endmodule
一次过，完美。今天就做到这里了，这一节题目有点多，有些题还有些复杂，估计还要再写两天了。
Fsm onehot
看着简单，但得找对思路，一开始我用的always@(*)并且标注出了S9~S0，但是由于该测试还会输入非独热码，会导致输出也并非全是独热码，所以要按照出题者的意图，直接将每一位作为一个状态直接进行判断。
moduletop_module(inputin,input[9:0]state,output[9:0]next_state,outputout1,outputout2);assignnext_state[0]=~in&&(state[4:0]||state[9:7]);assignnext_state[1]=in&&(state[0]||state[9:8]);assignnext_state[2]=in&&state[1];assignnext_state[3]=in&&state[2];assignnext_state[4]=in&&state[3];assignnext_state[5]=in&&state[4];assignnext_state[6]=in&&state[5];assignnext_state[7]=in&&state[7:6];assignnext_state[8]=~in&&state[5];assignnext_state[9]=~in&&state[6];assignout1=state[8]|state[9];assignout2=state[7]|state[9];endmodule
Fsm ps2
ps/2是早期鼠标和键盘的接口，现在已经基本被USB取代。
这道题只需要通过in[3]来判断数据传输什么时候结束即可。
moduletop_module(inputclk,input[7:0]in,inputreset,//Synchronous resetoutputdone);//parameterBYTE1=0,BYTE2=1,BYTE3=2,DONE=3;reg[1:0]state,next_state;//State transition logic (combinational)always@(*)begincase(state)BYTE1:next_state=in[3]?BYTE2:BYTE1;BYTE2:next_state=BYTE3;BYTE3:next_state=DONE;DONE:next_state=in[3]?BYTE2:BYTE1;endcaseend//State flip-flops (sequential)always@(posedgeclk)beginif(reset)state<=BYTE1;elsestate<=next_state;end//Output logicassigndone=(state==DONE);endmodule
Fsm ps2data
在上一题的基础上增加一个存储数据的功能.
注意，由于这里状态DONE的时候下一个状态直接就是BYTE2了，所以在DONE的时候就可以存储BYTE1了。
moduletop_module(inputclk,input[7:0]in,inputreset,//Synchronous resetoutputreg[23:0]out_bytes,outputdone);////FSM from fsm_ps2parameterBYTE1=0,BYTE2=1,BYTE3=2,DONE=3;reg[1:0]state,next_state;//State transition logic (combinational)always@(*)begincase(state)BYTE1:next_state=in[3]?BYTE2:BYTE1;BYTE2:next_state=BYTE3;BYTE3:next_state=DONE;DONE:next_state=in[3]?BYTE2:BYTE1;endcaseend//State flip-flops (sequential)always@(posedgeclk)beginif(reset)state<=BYTE1;elsestate<=next_state;end//Output logicassigndone=(state==DONE);//New: Datapath to store incoming bytes.always@(posedgeclk)beginif(reset)out_bytes<=d0;elsebegincase(state)BYTE1:out_bytes[23:16] <=in;BYTE2:out_bytes[15:8] <=in;BYTE3:out_bytes[7:0] <=in;DONE:out_bytes[23:16] <=in;endcaseendendendmodule
Fsm serial
又是一道正确率很低的题目。
一开始写的count==8，一直出错，要注意count=0也有一个周期的长度。
moduletop_module(inputclk,inputin,inputreset,//Synchronous resetoutputdone);parameterIDLE=0,START=1,DATA=2,STOP=3;reg[1:0]state,next_state;reg[3:0]count;always@(posedgeclk)beginif(reset)state<=IDLE;elsestate<=next_state;endalways@(posedgeclk)beginif(reset)count<=d0;elseif(state ==DATA)count<= (count>7)?count:count+1b1;elsecount<=d0;endalways@(*)begincase(state)IDLE:next_state=in?IDLE:START;START:next_state=DATA;DATA:beginif(count==7&&in)next_state=STOP;elseif(count>7&&in)next_state=IDLE;elsenext_state=DATA;endSTOP:next_state=in?IDLE:START;endcaseendassigndone=(state==STOP);endmodule
Fsm serialdata
使用state计数的话整体的数据采集会落后一个周期，所以这题的计数使用next_state来进行判断，所以上一题的7要改成8。
原理参考三段式状态机使用case(next_state)用作输出，否则使用case(state)输出会落后两个周期。
moduletop_module(inputclk,inputin,inputreset,//Synchronous resetoutputreg[7:0]out_byte,outputdone);////Use FSM from Fsm_serialparameterIDLE=0,START=1,DATA=2,STOP=3;reg[1:0]state,next_state;reg[3:0]count;always@(posedgeclk)beginif(reset)state<=IDLE;elsestate<=next_state;endalways@(posedgeclk)beginif(reset)count<=d0;elseif(next_state == DATA)beginout_byte<= {in,out_byte[7:1]};count<= (count>8)?count:count+1b1;endelsecount<=d0;endalways@(*)begincase(state)IDLE:next_state=in?IDLE:START;START:next_state=DATA;DATA:beginif(count==8&&in)next_state=STOP;elseif(count>8&&in)next_state=IDLE;elsenext_state=DATA;endSTOP:next_state=in?IDLE:START;endcaseendassigndone=(state==STOP);//New: Datapath to latch input bits.endmodule
Fsm serialdp
在上一题的基础上实现一个奇校验：通过加入一个冗余位，使得9位数据中的1的个数始终为奇数。
题目给了一个T触发器，即输入为1时，输出翻转的触发器，T触发一般使用一个JK触发器构成。
debug不能看全部信号的波形也太折磨了，最好还是用vivado仿真调一下。
在经过六次失败之后，终于成功了，错误的原因是T触发器的in信号经过了选通，导致可能少计了一个周期，其实reset位置合适，in可以直接连接到T触发器上。
moduletop_module(inputclk,inputin,inputreset,//Synchronous resetoutput[7:0]out_byte,outputdone);////Use FSM from Fsm_serialparameterIDLE=0,START=1,DATA=2,STOP=3;reg[1:0]state,next_state;reg[3:0]count;wireodd;reg[8:0]data;wireparity_reset;always@(posedgeclk)beginif(reset)state<=IDLE;elsestate<=next_state;endalways@(posedgeclk)beginif(reset)count<=d0;elseif(next_state == DATA)begindata<= {in,data[8:1]};count<= (count>9)?count:count+1b1;endelseif(next_state==START)count<=d0;endalways@(*)begincase(state)IDLE:next_state=in?IDLE:START;START:next_state=DATA;DATA:beginif(count==9&&in&&odd)next_state=STOP;elseif(count>=9&&in)next_state=IDLE;elsenext_state=DATA;endSTOP:next_state=in?IDLE:START;endcaseendassigndone=(state==STOP);//New: Datapath to latch input bits.//New: Add parity checking.parity u0(clk,parity_reset,in,odd);assignout_byte=data[7:0];assignparity_reset = reset||next_state ==IDLE||next_state ==START;endmodule
Fsm hdlc
序列检测器，这里有三个序列需要检测
0111110: Signal a bit needs to be discarded (disc).01111110: Flag the beginning/end of a frame (flag).01111111...: Error (7 or more 1s) (err).根据题目意思可以构建一个Moore状态机，结果发现和前面Fsm onehot中的状态机是一样的，这不是巧了吗。前面用的是独热码并且已经写出了状态转移方程，这里直接用就好了。
moduletop_module(inputclk,inputreset,//Synchronous resetinputin,outputdisc,outputflag,outputerr);reg[9:0]state;wire[9:0]next_state;parameterNONE=10d0000_0000_01;parameterONE=10d0000_0000_10;parameterTWO=10d0000_0001_00;parameterTHREE=10d0000_0010_00;parameterFOUR=10d0000_0100_00;parameterFIVE=10d0000_1000_00;parameterSIX=10d0001_0000_00;parameterERROR=10d0010_0000_00;parameterDISCARD=10d0100_0000_00;parameterFLAG=10d1000_0000_00;always@(posedgeclk)beginif(reset)state<=NONE;elsestate<=next_state;endassignnext_state[0]=~in&&(state[4:0]||state[9:7]);assignnext_state[1]=in&&(state[0]||state[9:8]);assignnext_state[2]=in&&state[1];assignnext_state[3]=in&&state[2];assignnext_state[4]=in&&state[3];assignnext_state[5]=in&&state[4];assignnext_state[6]=in&&state[5];assignnext_state[7]=in&&state[7:6];assignnext_state[8]=~in&&state[5];assignnext_state[9]=~in&&state[6];assignerr=state[7];assigndisc=state[8];assignflag=state[9];endmodule
有状态转换逻辑就是好写。
Exams/ece241 2013 q8
使用Mealy状态机，也就是输出和状态和输入都有关，这里使用Moore状态机会多一个状态.，而题目要求使用三个状态，所以最好使用Mealy状态机。
moduletop_module(inputclk,inputaresetn,//Asynchronous active-low resetinputx,outputz);reg[1:0]state,next_state;parameterS0=0,S1=1,S2=2;always@(posedgeclkornegedgearesetn)beginif(~aresetn)state<=S0;elsestate<=next_state;endalways@(*)begincase(state)S0:next_state=x?S1:S0;S1:next_state=x?S1:S2;S2:next_state=x?S1:S0;default:next_state=S0;endcaseendassignz=(state==S2)&&x;endmodule
这里使用的是两段式，输出直接使用组合逻辑。我一开始写的三段式，输出用的时序逻辑，输入会同时改变次态和输出，所以电路综合出来显示一直是0，晕。
下面是代码，用来当反面教材。
moduletop_module(inputclk,inputaresetn,//Asynchronous active-low resetinputx,outputregz);reg[1:0]state,next_state;parameterS0=0,S1=1,S2=2;always@(posedgeclkornegedgearesetn)beginif(~aresetn)state<=S0;elsestate<=next_state;endalways@(*)begincase(state)S0:next_state=x?S1:S0;S1:next_state=x?S1:S2;S2:next_state=x?S1:S0;default:next_state=S0;endcaseendalways@(posedgeclkornegedgearesetn)beginif(~aresetn)z<=1b0;elsebegincase(next_state)S0:z<=1b0;S1:z<=1b0;S2:z <=x;default:z <=1b0;endcaseendendendmodule
Exams/ece241 2014 q5a
这道题一开始没看懂啥意思，看了一下Rong晔大佬的视频才懂。
大概意思就是遇到第一个1时开始进行取反运算，由于1000的补码仍然是1000，所以第一个1保持不变，后面出现的高位全部取反。
注意这里只需要对输入进行补码运算，不需要也没有办法判断输入的数到底是正数还是负数（一开始就是没想清楚这一点），所以无脑对输入进行计算就可以了。
这里用S1代表需要输出1，S2代表需要输出0。
moduletop_module(inputclk,inputareset,inputx,outputz);reg[1:0]state,next_state;parameterS0=0,S1=1,S2=2;always@(posedgeclkorposedgeareset)beginif(areset)state<=S0;elsestate<=next_state;endalways@(*)begincase(state)S0:next_state=x?S1:S0;S1:next_state=x?S2:S1;S2:next_state=x?S2:S1;endcaseendassignz=(state==S1);endmodule
Exams/ece241 2014 q5b
和上一题是一样的，注意Moore状态机比Mealy状态机多一个状态，并且Mealy状态机直接使用组合逻辑输出会相比Moore状态机提前一个周期。
moduletop_module(inputclk,inputareset,inputx,outputz);reg[1:0]state,next_state;parameterS0=2b01,S1=2b10;always@(posedgeclkorposedgeareset)beginif(areset)state<=S0;elsestate<=next_state;endalways@(*)begincase(state)S0:next_state=x?S1:S0;S1:next_state=S1;default:next_state=S0;endcaseendassignz=(state[0]&&x)||(state[1]&&~x);endmodule
Exams/2014 q3fsm
这道题正确率只有13%
主要困难的地方在于计数每三个周期里w有多少个1，由于这里计数是连续的，所以w的计数不能简单的清零，在第一个周期时便可以开始判断w的值，并决定初始化为0还是1。
moduletop_module(inputclk,inputreset,//Synchronous resetinputs,inputw,outputz);parameterA=0,B=1;regstate,next_state;reg[1:0]w_count,count;always@(posedgeclk)beginif(reset)state<=A;elsestate<=next_state;endalways@(*)begincase(state)A:next_state=s?B:A;B:next_state=B;endcaseendalways@(posedgeclk)beginif(reset)count<=d0;elsebeginif((state==B)&&count <2)begincount<= count +1b1;endelsebegincount<=d0;endendendalways@(posedgeclk)beginif(reset)w_count<=d0;elseif(state==B)beginif(count==0)beginif(w)w_count<=d1;elsew_count<=d0;endelseif(w)w_count<=w_count+1b1;endendassignz=(count ==d0)&&(w_count==2);endmodule
Exams/2014 q3bfsm
终于来了一道简单题。
moduletop_module(inputclk,inputreset,//Synchronous resetinputx,outputz);parameterS0=3b000;parameterS1=3b001;parameterS2=3b010;parameterS3=3b011;parameterS4=3b100;reg[2:0]state,next_state;always@(posedgeclk)beginif(reset)state<=S0;elsestate<=next_state;endalways@(*)begincase(state)S0:next_state=x?S1:S0;S1:next_state=x?S4:S1;S2:next_state=x?S1:S2;S3:next_state=x?S2:S1;S4:next_state=x?S4:S3;default:next_state=S0;endcaseendassignz=(state==S3)||(state==S4);endmodule
Exams/2014 q3c
这道题给的clk没啥用。
moduletop_module(inputclk,input[2:0]y,inputx,outputY0,outputz);parameterS0=3b000;parameterS1=3b001;parameterS2=3b010;parameterS3=3b011;parameterS4=3b100;reg[2:0]next_state;always@(*)begincase(y)S0:next_state=x?S1:S0;S1:next_state=x?S4:S1;S2:next_state=x?S1:S2;S3:next_state=x?S2:S1;S4:next_state=x?S4:S3;default:next_state=S0;endcaseendassignz=(y==S3)||(y==S4);assignY0=next_state[0];endmodule
Exams/m2014 q6b
这题只要求把Y2逻辑写出来，Y2只在两种情况为1，即状态C和状态D，把所有会跳转到这两种状态的情况列举出来即可。
moduletop_module(input[3:1]y,inputw,outputY2);parameterA=3b000;parameterB=3b001;parameterC=3b010;parameterD=3b011;parameterE=3b100;parameterF=3b101;assignY2=(y==B&&~w)||(y==F&&~w)||(y==B&&w)||(y==C&&w)||(y==E&&w)||(y==F&&w);endmodule
Exams/m2014 q6c
做过的题型，要求使用独热码编码。
moduletop_module(input[6:1]y,inputw,outputY2,outputY4);parameterA=6b000_001;parameterB=6b000_010;parameterC=6b000_100;parameterD=6b001_000;parameterE=6b010_000;parameterF=6b100_000;assignY2=y[1]&&~w;assignY4=(y[2]&&w)||(y[3]&&w)||(y[5]&&w)||(y[6]&&w);endmodule
Exams/m2014 q6
直接接着上一题写。
moduletop_module(inputclk,inputreset,//synchronous resetinputw,outputz);parameterA=6b000_001;parameterB=6b000_010;parameterC=6b000_100;parameterD=6b001_000;parameterE=6b010_000;parameterF=6b100_000;reg[6:1]state,next_state;always@(posedgeclk)beginif(reset)state<=A;elsestate<=next_state;endassignnext_state[1]=(state[1]&&w)||(state[4]&&w);assignnext_state[2]=state[1]&&~w;assignnext_state[3]=(state[2]&&~w)||(state[6]&&~w);assignnext_state[4]=(state[2]&&w)||(state[3]&&w)||(state[5]&&w)||(state[6]&&w);assignnext_state[5]=(state[3]&&~w)||(state[5]&&~w);assignnext_state[6]=state[4]&&~w;assignz=state[5]||state[6];endmodule
Exams/2012 q2fsm
和上一题是一样的，只不过按题目要求用了两个always。
moduletop_module(inputclk,inputreset,//Synchronous active-high resetinputw,outputz);parameterA=3b000;parameterB=3b001;parameterC=3b010;parameterD=3b011;parameterE=3b100;parameterF=3b101;reg[6:1]state,next_state;always@(posedgeclk)beginif(reset)state<=A;elsestate<=next_state;endalways@(*)begincase(state)A:next_state=w?B:A;B:next_state=w?C:D;C:next_state=w?E:D;D:next_state=w?F:A;E:next_state=w?E:D;F:next_state=w?C:D;default:next_state=A;endcaseendassignz=(state==E)||(state==F);endmodule
Exams/2012 q2b
为啥还是这道题，稍微变了一点逻辑。
moduletop_module(input[5:0]y,inputw,outputY1,outputY3);assignY1=y[0]&&w;assignY3=(y[1]&&~w)||(y[2]&&~w)||(y[4]&&~w)||(y[5]&&~w);endmodule
Exams/2013 q2afsm
这个状态机是一个仲裁器，不难看出，三个设备具有不同的优先级，B>C>D，根据状态转移图不难得出方程。
一开始写错了，因为r1、r2、r3顺序搞错了，晕。
moduletop_module(inputclk,inputresetn,//active-low synchronous resetinput[3:1]r,//requestoutput[3:1]g//grant);parameterA=0,B=1,C=2,D=3;reg[1:0]state,next_state;always@(posedgeclk)beginif(~resetn)state<=A;elsestate<=next_state;endalways@(*)begincase(state)A:begincasex(r)3b000:next_state=A;3bxx1:next_state=B;3bx10:next_state=C;3b100:next_state=D;endcaseendB:next_state=r[1]?B:A;C:next_state=r[2]?C:A;D:next_state=r[3]?D:A;endcaseendassigng[1]=state==B;assigng[2]=state==C;assigng[3]=state==D;endmodule
Exams/2013 q2bfsm
疯狂加状态就完事了，主要是要理解题目意思，一步一步写就行了。
moduletop_module(inputclk,inputresetn,//active-low synchronous resetinputx,inputy,outputf,outputg);parameterA=0,B=1,C=2,D=3,E=4,F=5,G=6,H=7,I=8;reg[3:0]state,next_state;always@(posedgeclk)beginif(~resetn)state<=A;elsestate<=next_state;endalways@(*)begincase(state)A:next_state=B;B:next_state=C;C:next_state=x?D:C;D:next_state=x?D:E;E:next_state=x?F:C;F:next_state=y?H:G;G:next_state=y?H:I;H:next_state=H;//g=1I:next_state=I;//g=0;endcaseendassignf=(state==B);assigng=(state==F)||(state==G)||(state==H);endmodule
写了一个星期终于写完这一节了，泪目。
声明：本站所有文章，如无特殊说明或标注，均为爬虫抓取以及网友投稿，版权归原作者所有。
