HDLBits(十 一)学习笔记——有限状态机（FSM onehot - Fsm serialdp）

最新推荐文章于 2024-07-29 15:26:36 发布
最新推荐文章于 2024-07-29 15:26:36 发布
阅读量2.3k 收藏 9
点赞数 3
分类专栏： HDL Bits 学习 文章标签： fpga开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/H19981118/article/details/124329825
版权

FSM onehot

在这里插入图片描述
题目要求采用独热码的方式进行编写，其中state[0]和state[9]分别对应于S0和S9。除非另有指定，否则输出为零。并实现状态机的状态转换逻辑和输出逻辑部分，在状态[9：0]中，您将获得当前状态，并且必须产生next_state[9：0]和两个输出。
方法一：

module top_module(
    input in,
    input [9:0] state,
    output [9:0] next_state,
    output out1,
    output out2
);
  
    parameter S0 = 4'd0;
    parameter S1 = 4'd1;
    parameter S2 = 4'd2;
    parameter S3 = 4'd3;
    parameter S4 = 4'd4;
    parameter S5 = 4'd5;
    parameter S6 = 4'd6;
    parameter S7 = 4'd7;
    parameter S8 = 4'd8;
	parameter S9 = 4'd9;

   
    assign next_state[0] = ~in & (state[S0] | state[S1] | state[S2] | state[S3] | state[S4] | state[S7] | state[S8] | state[S9]);
    assign next_state[1] = in & (state[S0] | state[S8] | state[S9]);
    assign next_state[2] = in & state[S1];
    assign next_state[3] = in & state[S2];
    assign next_state[4] = in & state[S3];
    assign next_state[5] = in & state[S4];
    assign next_state[6] = in & state[S5];
    assign next_state[7] = in & (state[S6] | state[S7]);
    assign next_state[8] = ~in & state[S5];
    assign next_state[9] = ~in & state[S6];
    
    assign out1 = (state[S8] | state[S9]);
    assign out2 = (state[S7] | state[S9]);
  
endmodule

方法二：该方法逻辑正确，但时间上的仿真不能通过。因为题目给出采用 state[0] - state[9]分别对应于S0-S9的方式，无需比对每一位，仅对十位中的某一位进行状态分析，从而简化了表达，可节约时间。

module top_module(
    input in,
    input [9:0] state,
    output [9:0] next_state,
    output out1,
    output out2
);
//独热码
parameter S0 = 10'b0000000001;
parameter S1 = 10'b0000000010;
parameter S2 = 10'b0000000100;
parameter S3 = 10'b0000001000;
parameter S4 = 10'b0000010000;
parameter S5 = 10'b0000100000;
parameter S6 = 10'b0001000000;
parameter S7 = 10'b0010000000;
parameter S8 = 10'b0100000000;
parameter S9 = 10'b1000000000;
//第二段 组合逻辑进行状态跳转
        always @ (*)begin
            case(state)
                S0:begin
                    if(in == 1'b0)
                        next_state = S0;
                    else
                      next_state = S1;  
                end
                S1:begin
                    if(in == 1'b0)
                      next_state = S0;
                    else
                      next_state = S2;  
                end
                S2:begin
                    if(in == 1'b0)
                      next_state = S0;
                    else
                      next_state = S3;  
                end
                S3:begin
                    if(in == 1'b0)
                      next_state = S0;
                    else
                      next_state = S4;  
                end
                S4:begin
                    if(in == 1'b0)
                      next_state = S0;
                    else
                      next_state = S5;  
                end  
                S5:begin
                    if(in == 1'b0)
                      next_state = S8;
                    else
                      next_state = S6;  
                end
                S6:begin
                    if(in == 1'b0)
                      next_state = S9;
                    else
                      next_state = S7;  
                end
                S7:begin
                    if(in == 1'b0)
                      next_state = S0;
                    else
                      next_state = S7;  
                end
                S8:begin
                    if(in == 1'b0)
                      next_state = S0;
                    else
                      next_state = S1;  
                end
                S9: begin
                    if(in == 1'b0)
                      next_state = S0;
                    else
                      next_state = S1;  
                end
                default:next_state = 10'b0;
          
            endcase

    end
//第三段 描述输出
    assign out1 = (state == S8 | state == S9) ? 1:0;
    assign out2 = (state == S7 |state == S9) ? 1:0;

Fsm ps2

PS/2 鼠标协议发送长度为 3 个字节的消息。但是，在连续字节流中，消息的开始和结束位置并不明显。唯一的指示是，每个三字节消息的第一个字节始终具有 bit[3]=1（但其他两个字节的位 [3] 可能是 1 或 0，具体取决于数据）。

我们想要一个有限的状态机，当给定输入字节流时，它将搜索消息边界。我们将使用的算法是丢弃字节，直到我们看到一个位[3]=1的字节。然后，我们假设这是消息的字节 1，并在收到所有 3 个字节（完成）后发出接收消息的信号。

FSM 应在成功接收到每条消息的第三个字节后立即在周期内发出信号。在这里插入图片描述
题目分析：
该题是对接收的每三个字节产生一个完成信号。字节流是连续的，因此只需要检测边界，即可判断出三个字节的接收，题目中第一个字节更好判断始终为1，而另外两个字节可能为1也可能为0，因此我们就以检测第一个字节作为边界。设置一个等待状态，只要检测到1，那么即可跳转到第一个字节，紧接着依次接收，直到第三个字节完成，否则就一直等待。在这里插入图片描述

module top_module(
    input clk,
    input [7:0] in,
    input reset,    // Synchronous reset
    output done
); 
    reg [3:0] state;
    reg [3:0] next_state;

    parameter BYTE_FIRST = 4'b0001; //第1-3个字节
    parameter BYTE_SECOND = 4'b0010; 
    parameter BYTE_THIRD = 4'b0100; 
    parameter WAIT = 4'b1000; //等待状态
   
//第一段 用时序逻辑描述状态寄存器
    always @ (posedge clk or posedge reset)begin
        if(reset)
            state <= WAIT;
        else
           state <= next_state; 
    end
//第二段 用组合逻辑描述状态转换
    always @ (*)begin
        case(state)
            BYTE_FIRST:begin
                next_state = BYTE_SECOND;
            end
            BYTE_SECOND:begin
                next_state = BYTE_THIRD;
            end
            BYTE_THIRD:begin
                if(in[3]==1'b1)
                    next_state = BYTE_FIRST;
                else
                    next_state = WAIT;
            end
            WAIT: begin
                if(in[3]==1'b1)
                    next_state = BYTE_FIRST;
                else
                    next_state = WAIT;
            end   
            default:next_state = WAIT;
        endcase
    end

//第三段 用组合逻辑描述输出
    assign done = (state == BYTE_THIRD);
endmodule

Fsm ps2data

根据上题，现在，您已经有了一个状态机，它将识别 PS/2 字节流中的三字节消息，请添加一个数据路径，该数据路径还将在收到数据包时输出 24 位（3 字节）消息（out_bytes[23：16] 是第一个字节，out_bytes[15：8] 是第二个字节，依此类推）。
done信号时，out_bytes都需要有效。您可以在其他时间输出任何内容。在这里插入图片描述

module top_module(
    input clk,
    input [7:0] in,
    input reset,    // Synchronous reset
    output [23:0] out_bytes,
    output done
); 
    reg [3:0] state;
    reg [3:0] next_state;
    reg [23:0] out_bytes_reg;

    parameter BYTE_FIRST = 4'b0001; //第1-3个字节
    parameter BYTE_SECOND = 4'b0010; 
    parameter BYTE_THIRD = 4'b0100; 
    parameter DONE = 4'b1000; //完成状态
   
//第一段 用时序逻辑描述状态寄存器
    always @ (posedge clk or posedge reset)begin
        if(reset)
            state <= BYTE_FIRST;
        else
           state <= next_state; 
    end
//第二段 用组合逻辑描述状态转换
    always @ (*)begin
        case(state)
            BYTE_FIRST:begin
                if(in[3]==1'b1)
                    next_state = BYTE_SECOND;
                else
                    next_state = BYTE_FIRST;
            end
            BYTE_SECOND:begin
                next_state = BYTE_THIRD;
            end
            BYTE_THIRD:begin
                    next_state = DONE;
            end
            DONE: begin
                if(in[3]==1'b1)
                    next_state = BYTE_SECOND;
                else
                    next_state = BYTE_FIRST;
            end   
            default:next_state = BYTE_FIRST;
        endcase
    end

//第三段 用组合逻辑描述输出
    assign done = (state == DONE);

//输出24位数据
    always @ (posedge clk)begin
        if(next_state == BYTE_SECOND)
            out_bytes_reg[23:16] <= in;
        else if(next_state == BYTE_THIRD)
            out_bytes_reg[15:8] <= in;
        else if (next_state == DONE)
            out_bytes_reg[7:0] <= in;
        else
            out_bytes_reg <= 24'd0;
 end

    assign out_bytes = out_bytes_reg;

endmodule

Fsm serial（不需要将数据输出）

在许多（较旧的）串行通信协议中，每个数据字节都与一个起始位和一个停止位一起发送，以帮助接收方将字节与位流分隔开来。一种常见的方案是使用一个起始位 （0）、8 个数据位和 1 个停止位 （1）。当没有任何内容被传输（空闲）时，该行也位于逻辑 1 处。

设计一个有限的状态机，该状态机将在给定位流时识别何时正确接收字节。它需要识别起始位，等待所有8个数据位，然后验证停止位是否正确。**如果停止位未按预期出现，**则 FSM 必须等到找到停止位后再尝试接收下一个字节。
在这里插入图片描述
题目分析：该题有五个状态，空闲状态、开始状态、数据状态、停止状态和等待状态。其中空闲状态的时候根据输入in信号来判断，如果in=0，说明进入开始状态，否则仍然是空闲状态，从开始状态到数据状态，数据状态中需要特别注意，这里其实包含0-7 八位数据的接收，采用计数的方式来进行8个数据位的依次接收，当接收完成后仍然根据in信号，判断是否进入停止状态。如果数据位接收完成，但是输入停止位信号一直没过来，那就进去等待状态。
在这里插入图片描述

module top_module(
    input clk,
    input in,
    input reset,    // Synchronous reset
    output done
); 
 	parameter IDLE = 5'd00001;
    parameter START= 5'd00010;
    parameter DATA = 5'd00100;
    parameter STOP = 5'd01000;
    parameter WAIT = 5'd10000;
    
    reg [4:0]	state;
    reg [4:0]	next_state;
    reg [3:0]	count;

        
// 第一段 状态寄存器
    always @(posedge clk)begin
        if(reset)begin
            state <= IDLE;
        end
        else begin
            state <= next_state;
        end
    end
//第二段 组合逻辑描述状态转移
    always @(*)begin
        case(state)
            IDLE :begin
                if(in == 1'b0)
                    next_state = START;
                else
                    next_state = IDLE;
            end
            START:begin
                next_state = DATA;
            end
            DATA :begin
                if(count == 4'd7)begin //计数8次，说明8个数据接收完成
                    if(in == 1'b1) //出现停止位
                        next_state = STOP;
                    else
                        next_state = WAIT; 
                end
                else
                       next_state = DATA;
            end
            STOP :begin
                if(in == 1'b0)
                    next_state = START;
                else
                    next_state = IDLE;
            end
            WAIT :begin
                if(in == 1'b0)
                    next_state = WAIT;
                else
                    next_state = IDLE;
            end
            default:begin 
                next_state = IDLE;   
            end
        endcase
    end
//第三段 组合逻辑描述输出
    always @(*)begin
        if(reset)
            done = 1'b0;
        else if(state == STOP)
            done = 1'b1;
        else
            done = 1'b0;
    end
    
    
 //计数器设计
    always @(posedge clk)begin
        if(reset)
            count <= 4'b0;
        else if(state == DATA)begin
            count <= count + 1'b1;
        end
        else
            count <= 4'b0;
    end

endmodule

由此可看到在数据状态比较复杂，需要设计计数器，进行八次的计数，来确定八个数据位的接收，

Fsm serialdata 状态机串行数据

该题是在上题的基础上，将数据进行输出。也就是说该题的数据状态更复杂，不仅需要设计计数器，进行八次的计数，来确定八个数据位的接收，另外数据状态还要进行数据的输出，每一次计数，将一位的输入给数据输出缓存的对应位， par_in[count] <= in; 最后还要将将缓存的数据的八位给到输出。
在这里插入图片描述

module top_module(
    input clk,
    input in,
    input reset,    // Synchronous reset
    output [7:0] out_byte,
    output done
); 
 	parameter IDLE = 5'd00001;
    parameter START= 5'd00010;
    parameter DATA = 5'd00100;
    parameter STOP = 5'd01000;
    parameter WAIT = 5'd10000;
    
    reg [4:0]	state;
    reg [4:0]	next_state;
    reg [3:0]	count;
    reg [7:0]	par_in; //数据位是一位一位给的 共八位

        
// 第一段 状态寄存器
    always @(posedge clk)begin
        if(reset)begin
            state <= IDLE;
        end
        else begin
            state <= next_state;
        end
    end
//第二段 组合逻辑描述状态转移
    always @(*)begin
        case(state)
            IDLE :begin
                if(in == 1'b0)
                    next_state = START;
                else
                    next_state = IDLE;
            end
            START:begin
                next_state = DATA;
            end
            DATA :begin
                if(count == 4'd8)begin //计数8次，说明8个数据接收完成
                    if(in == 1'b1) //出现停止位
                        next_state = STOP;
                    else
                        next_state = WAIT; 
                end
                else
                       next_state = DATA;
            end
            STOP :begin
                if(in == 1'b0)
                    next_state = START;
                else
                    next_state = IDLE;
            end
            WAIT :begin
                if(in == 1'b0)
                    next_state = WAIT;
                else
                    next_state = IDLE;
            end
            default:begin 
                next_state = IDLE;   
            end
        endcase
    end
//第三段描述输出，可以采用一个always块来包含不同状态下所有的输出情况，这里为了
//对每个输出信号都清楚理解，分成不同三个多个always块来写。
 
 //输出数据接收寄存
    always @(posedge clk)begin
        if(reset)
            par_in[count] <= 1'd0;
        else if(next_state == DATA)
            par_in[count] <= in;
        else
            par_in[count] <= 1'd0;
    end
 //输出数据
    always @(posedge clk)begin
        if(reset)
            out_byte <= 8'd0;
        else if(next_state == STOP)
            out_byte <= par_in;  
        else
            out_byte <= 8'd0;
    end    
    
 //done信号
    always @(posedge clk)begin
        if(reset)begin
            done <= 1'd0;
        end
        else if(next_state == STOP)
            done <= 1'd1;
        else
            done <= 1'd0;
    end
    
 //设计计数器   
    always @(posedge clk)begin
        if(reset)begin
            count <= 4'd0;
        end   
        else if (next_state == DATA)
             count <= count + 1'd1;
         else
             count <= 4'd0;
     end
endmodule

Fsm serialdp（具有奇偶校验的串行接收器）

我们希望向串行接收器添加奇偶校验。奇偶校验在每个数据字节后增加一个额外的位。我们将使用奇数奇偶校验，其中收到的9位中的1的数量必须是奇数。例如，101001011满足奇数奇偶校验（有 5 个 1），但001001011不满足。

更改 FSM 和数据路径以执行奇数奇偶校验。仅当正确接收字节并且其奇偶校验通过时，才可确定done完成信号。另外此 FSM 需要标识起始位，等待所有 9 个（数据和奇偶校验）位，然后验证停止位是否正确。如果停止位未按预期出现，则 FSM 必须等到找到停止位后再尝试接收下一个字节。

为您提供了以下模块，可用于计算输入流的奇偶校验（这是一个具有重置功能的TFF）。预期的用途是，它应该被赋予输入位流，并在适当的时间复位，以便它计算每个字节中的1位数。

module parity (
    input clk,
    input reset,
    input in,
    output reg odd
    );

    always @(posedge clk)
        if (reset) odd <= 0;
        else if (in) odd <= ~odd;

endmodule

请注意，串行协议首先发送最低有效位，奇偶校验位在 8 个数据位之后发送。（最高位表示奇偶校验位）

module top_module(
    input clk,
    input in,
    input reset,    // Synchronous reset
    output [7:0] out_byte,
    output done
); 
 	parameter IDLE = 5'd00001;
    parameter START= 5'd00010;
    parameter DATA = 5'd00100;
    parameter STOP = 5'd01000;
    parameter WAIT = 5'd10000;
    
    reg [4:0]	state;
    reg [4:0]	next_state;
    reg [3:0]	count;
    reg [7:0]	par_in; //数据位是一位一位给的 共八位
    wire    Isdone;
    reg odd_temp;

        
// 第一段 状态寄存器
    always @(posedge clk)begin
        if(reset)begin
            state <= IDLE;
        end
        else begin
            state <= next_state;
        end
    end
//第二段 组合逻辑描述状态转移
    always @(*)begin
        case(state)
            IDLE :begin
                if(in == 1'b0)
                    next_state = START;
                else
                    next_state = IDLE;
            end
            START:begin
                next_state = DATA;
            end
            DATA :begin
                if(count == 4'd9)begin //计数8次，说明8个数据接收完成
                    if(in == 1'b1) //出现停止位
                        next_state = STOP;
                    else
                        next_state = WAIT; 
                end
                else
                       next_state = DATA;
            end
            STOP :begin
                if(in == 1'b0)
                    next_state = START;
                else
                    next_state = IDLE;
            end
            WAIT :begin
                if(in == 1'b0)
                    next_state = WAIT;
                else
                    next_state = IDLE;
            end
            default:begin 
                next_state = IDLE;   
            end
        endcase
    end
//第三段描述输出，可以采用一个always块来包含不同状态下所有的输出情况，这里为了
//对每个输出信号都清楚理解，分成不同三个多个always块来写。
 
 //输出数据接收寄存
    always @(posedge clk)begin
        if(reset)
            par_in[count] <= 1'd0;
        else if(next_state == DATA)
            par_in[count] <= in;
        else
            par_in[count] <= 1'd0;
    end
 //输出数据
    always @(posedge clk)begin
        if(reset)
            out_byte <= 8'd0;
        else if(next_state == STOP)begin
            if(odd_temp) //满足奇偶校验将接收的数据给输出
                out_byte <= par_in;
            else
                out_byte <= 8'd0;
          end  
        else
            out_byte <= 8'd0;
    end    
    
 //done信号
    always @(posedge clk)begin
        if(reset)begin
            done <= 1'd0;
        end
        else if(next_state == STOP)begin //STOP仅能说明接收了九位数据，但是还要进行检测看是否为奇数校验
            if(odd_temp)
                done <= 1'd1;
            else
                done <= 1'd0;
        end
        else
            done <= 1'd0;
    end
    

    assign Isdone = (next_state == START);
    parity u0(clk,Isdone,in,odd_temp);  
        
 //设计计数器   
    always @(posedge clk)begin
        if(reset)begin
            count <= 4'd0;
        end   
        else if (next_state == DATA)
             count <= count + 1'd1;
         else
             count <= 4'd0;
     end
     
endmodule
Fighting_FPGA
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
HDLBits_Fsm serialdp
Jennywangup的博客
11-30 231
相对于上一道题进行了修修改改，一直有10个mismatch，调整了一下状态机，最后终于成功啦。
python描述器 有限状态机_FPGA学习笔记（七）——FSM（Finite State Machine，有限状态机）设计...
weixin_35144647的博客
12-29 228
FPGA设计中，最重要的设计思想就是状态机的设计思想！状态机的本质就是对具有逻辑顺序和时序规律的事件的一种描述方法，它有三个要素：状态、输入、输出：状态也叫做状态变量(比如可以用电机的不同转速作为状态)，输出指在某一个状态的特定输出，输入指状态机中进入每个状态的条件。根据状态机的输出是否和输入有关，可分为摩尔(Moore)型状态机和米勒型(Mealy)状态机：摩尔型状态机的输出只取决于当前状态，而...
HDLBits: Fsm serialdp
XIANG
07-22 300
module top_module( input clk, input in, input reset, // Synchronous reset output [7:0] out_byte, output done ); parameter IDLE = 4'd0; parameter BIT0 = 4'd1; parameter BIT1 = 4'd2; parameter BIT2 = 4'd3; parameter BIT3 = 4'd4; pa...
HDLBIits学习：Fsm serialdp
最新发布
weixin_66492206的博客
07-29 903
See also: Serial receiver and datapathWe want to add parity checking to the serial receiver. Parity checking adds one extra bit after each data byte. We will use odd parity, where the number of 1s in the 9 bits received must be odd. For example, 101001011
HDLbits---Fsm serialdp
博主毕竟还是人，肯定会有错误，各位看的时候发现错误提出来就好
04-24 1520
HDLbits—Fsm serialdp 这道题真的恶心，当时用了个各种方法，加了各种状态，就是不成功，主要是想写成标准的三段式状态机，所以看了别的博主的方法感觉不适合自己。磨了三天才写出来，但是结果是好的，主要问题是奇偶检验模块的重置功能写的太随意了，感觉只要在一开始的时候控制一下重置就行了，结果就是开始和结束状态要好好控制。 module top_module( input clk, input in, input reset, // Synchronous reset
HDLBit 之 Fsm serialdp
qq_42282258的博客
05-28 319
1.原题复现 代码 思考过程 首先，可以根据上一题比较而言，这一题不过是多了一个校验位（这里要注意的是：这个校验位在停止位之前，校验位和停止位是分开的两个不同的bit，刚开始没写出来，就是因为这里没弄清楚） 上一题的题目见蓝色部分点击进入https://hdlbits.01xz.net/wiki/Fsm_serialdata 然后贴上该题的串行数据代码： module top_module( input clk, input in, input reset, // Synch
Fsm serialdp-HDLBits
weixin_42148466的博客
02-17 112
应该算是写的比较简洁的方法了，相比没有奇偶效验的情况没有新增状态。2、使out_byte不要将奇偶校验位更新进去。重点在于1、parity_reset的设置。
探索笔记 - 有限状态机（FSM）与观察者模式（或事件调度中心）与人工智障（AI)
qq_31293317的博客
07-13 678
Github：https://github.com/BellflowerRinging/UnityTest，Assets/src/MonoFSM/ 为了学习和测试有限状态机，设想了人工智障（Ai）的需求，在Unity上实现： 1.当玩家站立不动的时候，Ai转圈嘲讽玩家。 2.当玩家移动的时候，Ai逃离玩家并始终和玩家保持一定的距离进行嘲讽。 3.用观察者模式或者事件...
unity3d人工智能学习（7）——游戏状态机FSM
weixin_44292962的博客
10-20 701
游戏状态机FSM简述操作过程按钮状态的转换 简述 参考教程： Unity3D有限状态机（FSM）学习笔记【7】使用实例. FSM有限状态机学习及Unity3D案例讲解. 操作过程 按钮状态的转换 ...
一段式、两段式以及三段式状态机（FSM）设计实例
qq_33828149的博客
04-07 3253
一段式、二段式以及三段式状态机（FSM）设计实例状态机（FSM）分类状态转移的三种编码方式一段式、两段式状态机（FSM）区别vivado与modelsim联调显示状态机设计实例状态转移图代码定义代码段一段式状态机（FSM）两段式状态机（FSM）三段式状态机（FSM）vivado生成的综合视图后记 状态机（FSM）分类 **分类：**摩尔型（Moore）有限状态机，输出只由当前状态确定。米利型（Me...
状态机学习笔记
05-30
### 状态机学习笔记 #### 基本概念与事件定义 在状态机的设计与实现过程中，事件扮演着至关重要的角色。一个事件是指能够瞬间触发状态机执行特定操作的动作，它可以携带参数，这些参数提供了有关事件的具体信息。...
Fsm serialdata
aulloncheung的博客
03-07 235
See also:Serial receiver Now that you have a finite state machine that can identify when bytes are correctly received in a serial bitstream, add a datapath that will output the correctly-received data byte.out_byteneeds to be valid whendoneis1, and ...
[HDLbits]Fsm one hot
sometimeshappen的博客
03-08 952
@HDLbits FSM OneHot Question:Given the following state machine with 1 input and 2 outputs: Suppose this state machine uses one-hot encoding, where state[0] through state[9] correspond to the states S0 though S9, respectively. The outputs are zero unless o
[吾题有解] HDLBits : Fsm serialdp
shushisheng的博客
03-29 951
一道HDLBits上的FSM设计题，其中涉及奇偶校验、有效数据输出以及正确接收数据判断。
Fsm serialdp
m0_58080224的博客
03-21 456
module top_module( input clk, input in, input reset, // Synchronous reset output [7:0] out_byte, output done ); // parameter S0=0,S1=1,S2=2,S3=3,S4=4,S5=5; //S0等待start为1,start为1下个周期跳变至S1，S1接收8位数据，接收完后跳变至S4状态， //S4状态判断奇.
HDLBits-Fsm onehot
Shirin11的博客
05-14 148
module top_module( input in, input [9:0] state, output [9:0] next_state, output out1, output out2); parameter S0=0, S1=1, S2=2, S3=3, S4=4, S5=5, S6=6, S7=7, S8=8, S9=9; assign next_state[S0]= state[S0]&~in | state[S1.
HDLbits--fsm onehot
weixin_49574391的博客
06-23 184
eg：达到状态a需要in=0，state=0或者in=1，state=b；则语法为 next-a=~in&state[a] | in&state[b];独热码编码--仅仅检查输入状态就可以确定下一个状态 ，语句简单。类似于真值表输出，独热码编码可以保证字语句只有一句有效（为1）
HDLBits刷题记录——FSM之Serialdp奇校验二刷
JJJJJJJerry的博客
04-14 389
关于HDLBits状态机Fsm serialdp+odd parity一题的疑惑
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Fighting_FPGA

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值