Verilog 典型电路（零）：向量 1 检测

最新推荐文章于 2024-09-20 17:40:30 发布
最新推荐文章于 2024-09-20 17:40:30 发布
阅读量610 收藏 23
点赞数 21
分类专栏： Verilog 文章标签： fpga开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cegan/article/details/140859648
版权

文章目录

1 问题描述

给定位宽为 N 的向量，检测其从 高位到低位（MSB） 第一个 1 出现的位置，向量为 0 时输出 0。示例如下

输入向量输出向量
8’b0010_11018’b0010_0000
8’b0100_00008’b0100_0000
8’b0000_00008’b0000_0000

下述模块均采用 组合逻辑 实现，例化参数如下

参数描述
VECTOR_WIDTH向量位宽

端口定义如下

端口方向类型说明
seqIN[VECTOR_WIDTH-1:0]输入向量
posOUT[VECTOR_WIDTH-1:0]输出位置

1.1 仿真验证

由于不同方法所设计的模块端口完全相同，此处通过修改 VECTOR_DETECT_MODE 参数完成对不同模块的仿真测试，仿真文件如下

`timescale 1ns / 1ns

`define VECTOR_WIDTH 16
`define VECTOR_DETECT_MODE `VECTOR_DETECT_COMPL
`define VECTOR_DETECT_CASEZ 0
`define VECTOR_DETECT_DIVDE 1
`define VECTOR_DETECT_COMPL 2
`define VECTOR_DETECT_SHIFT_XOR 3

module vector_detect_tb;

    reg  [`VECTOR_WIDTH-1:0] seq;
    wire [`VECTOR_WIDTH-1:0] pos;

    generate
        if (`VECTOR_DETECT_MODE == `VECTOR_DETECT_CASEZ) begin
            vector_detect_casez vector_detect_casez_inst (
                .seq(seq),
                .pos(pos)
            );
        end else if (`VECTOR_DETECT_MODE == `VECTOR_DETECT_DIVDE) begin
            vector_detect_divide #(
                .VECTOR_WIDTH(`VECTOR_WIDTH)
            ) vector_detect_divde_inst (
                .seq(seq),
                .pos(pos)
            );
        end else if (`VECTOR_DETECT_MODE == `VECTOR_DETECT_COMPL) begin
            vector_detect_compl #(
                .VECTOR_WIDTH(`VECTOR_WIDTH)
            ) vector_detect_compl_inst (
                .seq(seq),
                .pos(pos)
            );
        end else if (`VECTOR_DETECT_MODE == `VECTOR_DETECT_SHIFT_XOR) begin
            vector_detect_shift_xor #(
                .VECTOR_WIDTH(`VECTOR_WIDTH)
            ) vector_detect_shift_xor_inst (
                .seq(seq),
                .pos(pos)
            );
        end
    endgenerate

    initial begin
        for (seq = 0; seq < ~0; seq = seq + 1'b1) begin
            #1;
        end
        #10 $stop;
    end

endmodule

注意：暴力破解法（VECTOR_DETECT_CASEZ）不支持参数化，因此修改 VECTOR_WIDTH 参数无效

1.2 性能测试

为对比不同模块的 资源占用 和 时序性能，此处在所有模块上对位宽 16 的向量进行综合测试，所有模块均在 Artix-7 系列 XC7A100TFTG256-1 平台综合实现（采用 默认综合策略），顶层模块和约束如下

`define VECTOR_WIDTH 16
`define VECTOR_DETECT_MODE `VECTOR_DETECT_COMPL
`define VECTOR_DETECT_CASEZ 0
`define VECTOR_DETECT_DIVDE 1
`define VECTOR_DETECT_COMPL 2
`define VECTOR_DETECT_SHIFT_XOR 3

module vector_detect_top (
    input                          clk,
    input                          rst_n,
    output reg [`VECTOR_WIDTH-1:0] pos
);

    reg  [`VECTOR_WIDTH-1:0] seq;
    wire [`VECTOR_WIDTH-1:0] pos_w;

    generate
        if (`VECTOR_DETECT_MODE == `VECTOR_DETECT_CASEZ) begin
            vector_detect_casez vector_detect_casez_inst (
                .seq(seq),
                .pos(pos_w)
            );
        end else if (`VECTOR_DETECT_MODE == `VECTOR_DETECT_DIVDE) begin
            vector_detect_divide #(
                .VECTOR_WIDTH(`VECTOR_WIDTH)
            ) vector_detect_divde_inst (
                .seq(seq),
                .pos(pos_w)
            );
        end else if (`VECTOR_DETECT_MODE == `VECTOR_DETECT_COMPL) begin
            vector_detect_compl #(
                .VECTOR_WIDTH(`VECTOR_WIDTH)
            ) vector_detect_compl_inst (
                .seq(seq),
                .pos(pos_w)
            );
        end else if (`VECTOR_DETECT_MODE == `VECTOR_DETECT_SHIFT_XOR) begin
            vector_detect_shift_xor #(
                .VECTOR_WIDTH(`VECTOR_WIDTH)
            ) vector_detect_shift_xor_inst (
                .seq(seq),
                .pos(pos_w)
            );
        end
    endgenerate

    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            seq <= 'b0;
        end else begin
            seq <= seq + 1'b1;
        end
    end

    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            pos <= 'b0;
        end else begin
            pos <= pos_w;
        end
    end
    
endmodule

create_clock -period 3.000 -name clk [get_ports clk]

不同模块的综合结果如下，综合考虑灵活性、资源占用和时序性能，推荐使用 二分法

FMAXLUTWNSTNS参数化资源占用工作频率
穷举法435 MHz200.057 ns0.156 ns❌⭐⭐⭐⭐
二分法455 MHz190.006 ns0.203 ns✅⭐⭐⭐⭐⭐⭐
独热加法345 MHz330.007 ns0.193 ns✅⭐⭐
错位相或法435 MHz190.045 ns0.216 ns✅⭐⭐⭐⭐⭐
  1. FMAX 即最大工作频率，由满足 WNS 和 TNS 均大于 0 条件的最小时钟周期换算而来
  2. 为了满足时序要求，综合工具往往会通过插入寄存器等方法对模块进行优化，因此同一模块不同工作频率下的资源占用不尽相同。此处资源数据为 FMAX 工作频率下 顶层文件 的资源占用，仅供参考
  3. 不同模块 FMAX 相同时 不能 通过 WNS 和 TNS 比较性能，因为 Vivado 采用 尽力而为 的综合策略，即以满足时序要求为目标，不追求宽裕的 WNS 和 TNS

2 模块实现

本文提供了常用的 穷举法、二分法、独热加法 和 错位相减法 四种向量 1 检测思路和具体实现，实际上向量 1 检测的思路还有很多，比如遍历向量所有比特位

generate
    for (genvar i = 0; i < VECTOR_WIDTH - 1; i = i + 1) begin
        assign pos[i] = seq[VECTOR_WIDTH-1:i+1] ? 1'b0 : seq[i];
    end
endgenerate

assign pos[VECTOR_WIDTH-1] = seq[VECTOR_WIDTH-1];

或者使用 if-else

if (seq[15]) begin
	pos = 16'b1000_0000_0000_0000;
end
else if (seq[14]) begin
	pos = 16'b0100_0000_0000_0000;
end
else if ...

上述方法或与本文所提方法 思路相似，或 性能和资源占用 没有优势，因此没有列出

2.1 穷举法

简洁明了，无需多言

module vector_detect_casez (
    input      [15:0] seq,
    output reg [15:0] pos
);

    always @(*) begin
        casex (seq)
            16'b1xxx_xxxx_xxxx_xxxx: pos = 16'b1000_0000_0000_0000;
            16'bx1xx_xxxx_xxxx_xxxx: pos = 16'b0100_0000_0000_0000;
            16'bxx1x_xxxx_xxxx_xxxx: pos = 16'b0010_0000_0000_0000;
            16'bxxx1_xxxx_xxxx_xxxx: pos = 16'b0001_0000_0000_0000;
            16'bxxxx_1xxx_xxxx_xxxx: pos = 16'b0000_1000_0000_0000;
            16'bxxxx_x1xx_xxxx_xxxx: pos = 16'b0000_0100_0000_0000;
            16'bxxxx_xx1x_xxxx_xxxx: pos = 16'b0000_0010_0000_0000;
            16'bxxxx_xxx1_xxxx_xxxx: pos = 16'b0000_0001_0000_0000;
            16'bxxxx_xxxx_1xxx_xxxx: pos = 16'b0000_0000_1000_0000;
            16'bxxxx_xxxx_x1xx_xxxx: pos = 16'b0000_0000_0100_0000;
            16'bxxxx_xxxx_xx1x_xxxx: pos = 16'b0000_0000_0010_0000;
            16'bxxxx_xxxx_xxx1_xxxx: pos = 16'b0000_0000_0001_0000;
            16'bxxxx_xxxx_xxxx_1xxx: pos = 16'b0000_0000_0000_1000;
            16'bxxxx_xxxx_xxxx_x1xx: pos = 16'b0000_0000_0000_0100;
            16'bxxxx_xxxx_xxxx_xx1x: pos = 16'b0000_0000_0000_0010;
            16'bxxxx_xxxx_xxxx_xxx1: pos = 16'b0000_0000_0000_0001;
            default:      pos = 8'b0000_0000;
        endcase
    end

endmodule

穷举法性能和资源占用中规中矩，主要缺点是 无法参数化

2.2 二分法

将向量 V 分为两个 位宽相等 的子向量 A 和 B，即 V = { A , B } V=\left\{A,B\right\} V={A,B}，分别在 A 和 B 中寻找第一个 1 的位置（此处采用 递归 算法实现）

  • 如果 A 不为 0，则第一个 1 在 A 中
  • 如果 A 为 0，则第一个 1 可能在 B 中（也可能为 0）

该模块递归向量阈值为 2，因此 向量位宽必须为偶数。如果向量位宽为奇数，可将其分为 1bit + 偶数位宽向量

module vector_detect_divide #(
    parameter  VECTOR_WIDTH     = 16,
    localparam VECTOR_SUB_WIDTH = VECTOR_WIDTH >> 1
) (
    input  [VECTOR_WIDTH-1:0] seq,
    output [VECTOR_WIDTH-1:0] pos
);

    wire [1:0][VECTOR_SUB_WIDTH-1:0] sub_pos;

    generate
        if (VECTOR_WIDTH == 2) begin
            assign pos = { seq[1], seq[1] ? 1'b0 : seq[0] };
        end else begin
            vector_detect_divide #(
                .VECTOR_WIDTH(VECTOR_SUB_WIDTH)
            ) vector_detect_0 (
                .seq(seq[0+:VECTOR_SUB_WIDTH]),
                .pos(sub_pos[0])
            );

            vector_detect_divide #(
                .VECTOR_WIDTH(VECTOR_SUB_WIDTH)
            ) vector_detect_1 (
                .seq(seq[VECTOR_WIDTH-1-:VECTOR_SUB_WIDTH]),
                .pos(sub_pos[1])
            );

            assign pos[VECTOR_WIDTH-1-:VECTOR_SUB_WIDTH] = sub_pos[1];
            assign pos[0+:VECTOR_SUB_WIDTH] = sub_pos[1] ? 'b0 : sub_pos[0];
        end
    endgenerate

endmodule

二分法资源占用和时序性能都比较优秀，且可以参数化，推荐使用

2.3 独热加法

非常巧妙的方法，但由于引入了加法器，资源占用和时序性能均比较差

module vector_detect_compl #(
    parameter VECTOR_WIDTH = 16
) (
    input  [VECTOR_WIDTH-1:0] seq,
    output [VECTOR_WIDTH-1:0] pos
);

    wire [VECTOR_WIDTH-1:0] seq_trans;
    wire [VECTOR_WIDTH-1:0] pos_trans = (~seq_trans + 1'b1) & seq_trans;

    generate
        for (genvar i = 0; i < VECTOR_WIDTH; i = i + 1) begin
            assign seq_trans[i] = seq[VECTOR_WIDTH-1-i];
        end
    endgenerate

    generate
        for (genvar i = 0; i < VECTOR_WIDTH; i = i + 1) begin
            assign pos[i] = pos_trans[VECTOR_WIDTH-1-i];
        end
    endgenerate

endmodule

2.4 错位相或法

考虑向量
V = 8 ′ b 01001010 V=8'b01001010 V=8′b01001010
如果能通过某种方法构造出如下向量

  • A = 8 ′ b 01000000 A=8'b01000000 A=8′b01000000（或 B = 8 ′ b 10111111 B=8'b10111111 B=8′b10111111）
  • C = 8 ′ b 11000000 C=8'b11000000 C=8′b11000000（或 D = 8 ′ b 00111111 D=8'b00111111 D=8′b00111111）

那么通过简单运算（与、非等）即可得到向量中的第一个 1，下面将介绍如何构造向量 D = 8 ′ b 00111111 D=8'b00111111 D=8′b00111111（向量中第一个 1 及之前的位置均为 0，之后的位置均为 1）

  1. 由向量 D D D 定义可知 D [ 7 ] = 0 D[7]=0 D[7]=0
  2. D [ 6 ] = V [ 7 ]   ∣   D [ 7 ] = 0   ∣   0 = 0 D[6]=V[7]\ |\ D[7]=0\ |\ 0=0 D[6]=V[7] ∣ D[7]=0 ∣ 0=0
  3. D [ 5 ] = V [ 6 ]   ∣   D [ 6 ] = 1   ∣   0 = 1 D[5]=V[6]\ |\ D[6]=1\ |\ 0=1 D[5]=V[6] ∣ D[6]=1 ∣ 0=1
  4. . . . ... ...
  5. D [ n − 1 ] = V [ n ]   ∣   D [ n ] D[n-1]=V[n]\ |\ D[n] D[n−1]=V[n] ∣ D[n]

上述计算方法看起来可能有点突兀，我们不妨代入所有递推公式
D [ n ] = V [ n + 1 ]   ∣   D [ n + 1 ] = V [ n + 1 ]   ∣   V [ n + 2 ]   ∣   D [ n + 2 ] = . . . = V [ n + 1 ]   ∣   V [ n + 2 ]   ∣   . . . V [ N − 1 ] D[n]=V[n+1]\ |\ D[n+1]=V[n+1]\ |\ V[n+2]\ |\ D[n+2]=...=V[n+1]\ |\ V[n+2]\ |\ ...V[N-1] D[n]=V[n+1] ∣ D[n+1]=V[n+1] ∣ V[n+2] ∣ D[n+2]=...=V[n+1] ∣ V[n+2] ∣ ...V[N−1]
显然，向量 D D D 中的每个比特位，实际上就是 向量 V V V 在该位置前所有比特的或值。某种程度上说，这也是一种“遍历”算法，用 Verilog 描述可能更为直观

wire [VECTOR_WIDTH-1:0] D;

assign D[VECTOR_WIDTH-1] = 1'b0;

generate
    for (genvar i = 0; i < VECTOR_WIDTH-1; i = i + 1) begin
        assign D[i] = |[VECTOR_WIDTH-1:i+1];
    end
endgenerate

上述代码稍加改造其实可以直接求出向量 V V V 中的第一个 1 的位置

module vector_detect_shift_ergodic #(
    parameter VECTOR_WIDTH = 16
) (
    input  [VECTOR_WIDTH-1:0] seq,
    output [VECTOR_WIDTH-1:0] pos
);

    assign pos[VECTOR_WIDTH-1] = seq[VECTOR_WIDTH-1:0];

    generate
        for (genvar i = 0; i < VECTOR_WIDTH-1; i = i + 1) begin
            assign pos[i] = [VECTOR_WIDTH-1:i+1] ? 1'b0 : seq[i];
        end
    endgenerate

endmodule

然而经过综合测试，上述模块的资源占用和时序性能都比较差，因此没有单独列出。下面给出 错位相或法 的具体实现，其中 seq_pre 即构建出的向量 D D D

module vector_detect_shift_xor #(
    parameter VECTOR_WIDTH = 16
) (
    input  [VECTOR_WIDTH-1:0] seq,
    output [VECTOR_WIDTH-1:0] pos
);

    wire [VECTOR_WIDTH-1:0] seq_pre;

    assign seq_pre = { 1'b0, seq[VECTOR_WIDTH-1:1] | seq_pre[VECTOR_WIDTH-1:1] };
    assign pos = seq & (~seq_pre);

endmodule

错位相或法在 时序要求不高时资源占用最少，可结合实际应用选择

3 拓展应用

向量 1 检测属于比较基础的模块，下面将介绍一些拓展应用

3.1 LSB

从向量的低位到高位，寻找第一个 1 出现的位置。这个实现其实非常简单，只要将输入输出的高低位顺序调换即可

module vector_detect_r2l #(
    parameter VECTOR_WIDTH	= 16
) (
    input  [VECTOR_WIDTH-1:0] seq,
    output [VECTOR_WIDTH-1:0] pos
);

    wire [VECTOR_WIDTH-1:0] seq_trans;
    wire [VECTOR_WIDTH-1:0] pos_trans;

    generate
        for (genvar i = 0; i < VECTOR_WIDTH; i = i + 1) begin
            assign seq_trans[i] = seq[VECTOR_WIDTH-1-i];
            assign pos[i] = pos_trans[VECTOR_WIDTH-1-i];
        end
    endgenerate

    vector_detect_l2r #(
        .VECTOR_WIDTH(VECTOR_WIDTH)
    ) vector_detect_l2r_inst (
        .seq(seq_trans),
        .pos(pos_trans)
    );

endmodule

3.2 双向 1 检测

分别从高位到低位、从低位到高位寻找第一个 1 出现的位置，示例如下

输入向量输出向量
8’b0010_11018’b0010_0001
8’b0100_00008’b0100_0000
8’b0000_00008’b0000_0000

该模块的实现也比较简单，将 MSB 和 LSB 输出相或即可

module vector_detect_both_side #(
    parameter VECTOR_WIDTH	= 16
) (
    input  [VECTOR_WIDTH-1:0] seq,
    output [VECTOR_WIDTH-1:0] pos
);

    wire [VECTOR_WIDTH-1:0] pos_l2r;
    wire [VECTOR_WIDTH-1:0] pos_rtl;
    
    assign pos = pos_l2r | pos_r2l;

    vector_detect_l2r #(
        .VECTOR_WIDTH(VECTOR_WIDTH)
    ) vector_detect_l2r_inst (
        .seq(seq),
        .pos(pos_l2r)
    );
    
    vector_detect_r2l #(
        .VECTOR_WIDTH(VECTOR_WIDTH)
    ) vector_detect_r2l_inst (
        .seq(seq),
        .pos(pos_r2l)
    );

endmodule

4 参考资料

  1. 关于“1”的verilig相关手撕代码
  2. Verilog找向量中的第一个1位置-一些想法
异步时刻
关注
专栏目录
一切皆是映射：实现神经网络的硬件加速技术：GPU、ASIC（专用集成电路）和FPGA（现场可编程门阵列）
AI天才研究院
07-06 1377
在人工智能和深度学习领域，神经网络已经成为一种revolutionary的技术，推动了诸如计算机视觉、自然语言处理和语音识别等领域的巨大进步。然而，随着神经网络模型变得越来越复杂和庞大，传统的CPU处理器在处理这些计算密集型任务时往往力不从心。这就催生了对专门的硬件加速技术的需求，以提高神经网络的训练和推理效率。在这篇文章中，我们将深入探讨三种主要的硬件加速技术：GPU（图形处理器）、ASIC（专用集成电路）和FPGA（现场可编程门阵列）。这些技术各有特点，都在神经网络加速领域发挥着重要作用。
verilog手撕代码——找出高位或低位第一个出现1
weixin_45260499的博客
12-20 2103
找出高位或者低位第一个1
Verilog手撕代码（11）1检测（统计个数、独热码检测、1的位置检测）
m0_51965113的博客
06-25 5644
那么我们就可以利用一个for循环，把每一位相加，最后再把最终的结果和1比较一下，如果是1，那就是独热码，如果不是1，那就是其他的数。对于一个4位的二进制数，我们对这4位奇偶校验，利用异或门依次进行每一位，最后的结果如果是奇数个1那么4位异或之后结果就是1，如果偶数个1那么结果就是0。独热码是一种二进制编码方式，它的特点是，用来编码这个数的N位bit中，有且只有一位是1，其余位全部为0。因为只有1位是1，所以叫做one-hot （对应的，还有一种编码方式是只有1位是0，其余位都是1，叫做one-cold)
Verilog设计，找到第一个1的位置
weixin_45704530的博客
08-14 1607
输入一个多bit的数，找到第一个1的位置。
用Verilog实现寻找第一个1和最后一个1的位置
我的blog屋
08-14 5156
用Verilog实现寻找数据 第一个1和最后一个1的位置 寻找数据中的第一个1的位置 // find fist one module find_ones( input [7:0] x, output [2:0] y); wire [3:0] data_4; wire [1:0] data_2; assign y[2] = | x[7:4]; assign data_4= y[2] ? x[7:4] : x[3:0] ; assign y[1] = | data_4[3:2]; assign dat..
Verilog设计_找到1的位置
2301_76660661的博客
03-03 4819
在输入数据中找到1的位置：找到第一个1的位置和最后一个1的位置。 给出了两种设计方法：第一种使用二分法，但是有一定局限性；第二种则是通用的参数化设计方法。
Verilog HDL 语言笔记
FTer_gxs的博客
12-18 2656
模块的结构 Verilog程序的基本设计单元是“模块”，模块完全定义在module 和endmodule关键字之间。 每个模块包含四个主要部分：模块声明，端口定义，数据类型说明和 逻辑功能描述。 module <模块名> （ <端口> <端口> ...... ）; <端口定义> <数据类型说...
数字集成电路设计简介：从门电路到芯片级集成
# 1. 数字集成电路概述 ## 1.1 数字集成电路的定义与分类 数字集成电路（Digital Integrated Circuit，简称DIC）是一种由多个晶体管与其他电子元件组成的电路，主要用于处理和传输数字信号。与模拟电路相比，数字...
verilog always语法_Verilog 最全经验总结（建议收藏）
weixin_39628247的博客
10-21 5927
关注、星标公众号，直达精彩内容公众号：ZYNQID ：FreeZynq1、不使用初始化语句；2、不使用延时语句；3、不使用循环次数不确定的语句，如：forever，while等；4、尽量采用同步方式设计电路；5、尽量采用行为语句完成设计；6、always过程块描述组合逻辑，应在敏感信号表中列出所有的输入信号；7、所有的内部寄存器都应该可以被复位；8、用户自定义原件(UDP元件)是不能被综...
目标检测YOLO实战应用案例100讲-智能目标检测系统在FPGA中的设计与实现
qq_36130719的博客
06-06 2353
本文结合FPGA芯片的高并行、低功耗、可重配置等优势，对基于卷积神经网络结构的目标检测算法，在端侧场景下的加速与部署进行研究与实现。本章节对本文涉及到的基本理论知识与技术手段进行介绍，为后续系统的方案分析与系统设计奠定理论基础。首先，介绍了卷积神经网络的基本组成部分及其原理。然后，对FPGA及其开发技术进行简单介绍。最后，对当前常用的部分基于FPGA的卷积神经网络加速方法进行概述。
verilog-5| 找到序列第一个1、最后一个1、第一个0
最新发布
m0_62869075的博客
09-20 588
个人学习简单总结，方便自己后续查询和复习一、找到序列的第一个1方式一：一个数和它的补码相与；方式二：参考第一个1的思路。
Total Negative Slack ( TNS ) Worst Negative Slack ( WNS )
Blaze_Xu的博客
12-31 2978
The “Worst Negative Slack (WNS)” reported by commands like report_timing_summary is actually the worst positive slack. If WNS is positive then it means that the path passes. If it is negative, then it means the path fails. So, this is really a misnomer. Th
【Vivado那些事儿】VIVADO中时序报告中WNS，WHS，TNS，THS含义
OpenFPGA的博客
10-16 1万+
VIVADO中时序报告中WNS，WHS，TNS，THS含义运行“report_timing”或“report_timing_summary”命令后，会注意到 WNS、TNS、WHS 和 T...
【小技巧】FPGA工程综合后出现WNS或者TNS小于零的问题处理
热门推荐
FPGA/MATLAB学习教程/源码/项目合作开发
05-30 1万+
通常情况下，如果出现程序设计不合理，时序优化不到位等问题，vivado在布局布线之后，会出现WNS，TNS小于零的情况，如下图所示： 当WNS和TNS较小时，对于一些低速的FPGA工程，可以忽略，不影响系统的工作性能，而当WNS或者TNS负数较大时，那么必须对其进行时序约束，否则会导致系统工作稳定性变差。 具体操作如下： 选择 从中找到红色小于0的路径，然后鼠标右击，在弹出菜单中设置set_false_path，然后将产生的约束语句复制到约束文件中： FALSE PATH就是.
用verilog实现检测1的个数_基于verilog实现数据检测
weixin_42479284的博客
01-13 6190
对于发送端发送送来的数据流，我们需要检测出其帧头来判断一帧的开始，从而开始接收数据。本人采用了接收1011010码流的例子来讲解如何实现数据流的检测。首先，先画好接收码流的状态图：这里做下简单的解释：当前数据为0时，一直等待1的到来，1到后跳转S1状态(已检测数据1)，在等待0的到来，如果数据为1到则返回IDLE(图上写错了)从新开始检测；此时接收了10了，状态跳转S2(已检测数据10)，继续检测...
向量前导1检测器的3种verilog实现方案
这么多免费帖子, 赶紧开张吧
01-16 3341
一、要求 设计一个组合逻辑电路，检测输入32位0/1向量中从高到低第一个1出现的位置，如果向量为全0则输出32。例如： 输入00011000 10000000 00000000 00000000，输出3； 输入00000000 11111111 00000000 00000000，输出8； 输入00000000 00000000 00000000 00001010，输出28. 模块输入输出功能定义： 名称 方向 位宽 描述
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值