Barrel Shifter RTL Combinational Circuit——桶移位寄存器SystemVerilog实现

已于 2024-01-21 16:47:48 修改
阅读量2.4k 收藏 27
点赞数 33
分类专栏： SystemVerilog 文章标签： SystemVerilog
于 2024-01-20 15:57:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46264636/article/details/135716634
版权

在本博客中，将围绕许多设计中存在的非常有用的电路（桶形移位器电路）设计电路。将从最简单的方法开始实现固定位宽字的单向旋转桶形移位器，最后设计一个具有可参数化字宽的多功能双向桶形移位器电路。

Barrel Shifter

桶形移位器是一种数字电路，可以将数据字移位指定位数，而不使用任何顺序逻辑，仅使用纯组合逻辑。它有一个控制输入，指定它移动的位数。桶移位器类似于移位寄存器（多位），不同之处在于寄存器的移位位被移回寄存器的另一端。例如，在右移操作中，从寄存器移出的 LSB 被移入 MSB。

桶形移位器适用于数字信号处理器和处理器。

实现桶形移位器的一种方法是作为一系列多路复用器，其中一个多路复用器的输出以取决于移位距离的方式连接到下一个多路复用器的输入。当使用一系列移位多路复用器实现桶式移位器时，对于不同的 k k k 值，每个多路复用器将一个字移位 2 k 2^k 2k 位位置（ 1 , 2 , 4 , 8 , 16 , 32... 1,2,4,8,16,32... 1,2,4,8,16,32...）。复用级的数量与输入向量的宽度有关。

下图显示了 32 位字的右移桶形移位器。
在这里插入图片描述
通过更复杂的多路复用器和一些用于处理末端填充选项的额外电路，桶形移位器可以处理处理器指令集中的所有标准位移指令。

Simple 8-bit right rotator

从最简单、最直接的方法开始，使用包含所有可能旋转组合的 case 语句，在 Verilog HDL 中对右移桶形移位器进行编程。

将设计一个简单的 8 位桶式移位器，它可以向右旋转任意位数。该电路有一个 8 位数据输入 data 和一个 3 位控制信号 amt，它指定要旋转的量。
该设计使用选定的信号分配语句来详尽地列出 amt 信号和相应旋转结果的所有组合。
使用 case 语句的 SystemVerilog 实现

`timescale 1ns / 10ps

module barrel_shifter_built_case(
    input logic [7:0] data,
    input logic [2:0] amt,
    output logic [7:0] out
);

    always_comb
    begin
        case (amt)
            3'o0: out = data;
            3'o1: out = {data[0], data[7:1]};
            3'o2: out = {data[1:0], data[7:2]};
            3'o3: out = {data[2:0], data[7:3]};
            3'o4: out = {data[3:0], data[7:4]};
            3'o5: out = {data[4:0], data[7:5]};
            3'o6: out = {data[5:0], data[7:6]};
            default  out = {data[6:0], data[7]};
        endcase
    end
endmodule

Test bench and simulation
测试台使用 for 循环来迭代指示旋转量的信号的所有可能性。

`timescale 1ns / 10ps

module barrel_shifter_built_case_testbench;
    logic [7:0] data;
    logic [2:0] amt;
    logic [7:0] out;

    barrel_shifter_built_case uut(.*);

    initial begin
        for (byte i = 0; i < 8; ++i)
            begin
                data = 8'b1111_0000; amt = 3'(i); #10;
            end
        $stop;
    end

endmodule

在示波器图像中,可以看到值如何移至右侧 amt 位、LSB 位，以及 MSB 如何填充溢出位，从而从左到右旋转信息。
在这里插入图片描述#### RTL Elaborated Design Schematics

这种设计桶形移位器的方法意味着使用宽 3 至 8 多路复用器

在这里插入图片描述
该代码很简单，但意味着一个宽复用器，这使得合成变得困难并导致较大的传播延迟。

如果输入位数增加就会很麻烦。

综合设计原理图

在这里插入图片描述

Simple staged 8-bit right rotator

或者，我们可以分阶段构建电路。在第 n n n 级中，输入信号要么直接传递到输出，要么向右旋转 2 n 2^n 2n 个位置。第 n n n级由 a m t amt amt 信号的第 n n n 位控制。
如果 a m 2 , a m 1 , a m 0 {am2, am1, am0} am2,am1,am0 是 a m t amt amt 信号的3位，则三级后总旋转量为 a m 2 ∗ 2 2 + a m 1 ∗ 2 + a m 0 am2 * 2^2 + am1 * 2 + am0 am2∗22+am1∗2+am0，这就是所需的旋转量。

`timescale 1ns / 10ps

module barrel_shifter_staged(
    input logic [7:0] data,
    input logic [2:0] amt,
    output logic [7:0] out
);

    logic [7:0] stage0;
    logic [7:0] stage1;

    always_comb
    begin
        //stage 0, shift 0 or 1 bit
        if(amt[0]) begin
            stage0 = {data[0], data[7:1]};
        end else
            begin
                stage0 = data;
            end

        //stage 1, shift 0 or 2 bits
        if(amt[1]) begin
            stage1 = {stage0[1:0], stage0[7:2]};
        end else
            begin
                stage1 = stage0;
            end

        //stage 2, shift 0 or 4 bits
        if(amt[2]) begin
            out = {stage1[3:0], stage1[7:4]};
        end else
            begin
                out = stage1;
            end
    end

endmodule

或者使用“?:”三元表达式更紧凑但并不更清晰。

module barrel_shifter_staged(
    input logic [7:0] data,
    input logic [2:0] amt,
    output logic [7:0] out
);

    logic [7:0] s0;
    logic [7:0] s1;

    assign s0  = amt[0]? {data[0], data[7:1]} :data ;
    assign s1  = amt[1]? {s0[1:0], s0[7:2]} :s0 ;
    assign out = amt[2]? {s1[3:0], s1[7:4]} :s1;
endmodule

该电路现在使用一系列 2 比 1 多路复用器
The circuit now uses a series of 2 to 1 multiplexors

在这里插入图片描述在这里插入图片描述

Multi-function barrel shifter. Rotating right or left.

将通过添加一个新信号使我们的桶式移位器变得复杂一些，该信号允许控制位移位的方向。通过这个信号，可以告诉桶形移位器电路，是否希望输出的位向右或向左移动一定数量的位。
这个8位移位电路可以执行右旋转和左旋转操作。附加的 1 位控制信号 dir_lr 指定所需的方向。
首先，将使用一个右循环电路、一个左循环电路和 2 对 1 多路复用器来设计电路来选择所需的结果。
A possible SystemVerilog implementation

`timescale 1ns / 10ps
const logic ROTATE_LEFT = 1'b1;
const logic ROTATE_RIGHT = 1'b0;

module barrel_shifter_multifunction(
    input logic [7:0] data,
    input logic [2:0] amt,
    input logic dir_lr, // 1 rotate left, 0 rotate right
    output logic [7:0] out
);
    logic [7:0] outl;
    logic [7:0] outr;
    barrel_shifter_right bsr(.*, .out(outr));
    barrel_shifter_left bsl(.*, .out(outl));

    assign out = dir_lr == ROTATE_LEFT ? outl:outr;

endmodule

// rotates amt bits of data to the right
module barrel_shifter_right(
    input logic [7:0] data,
    input logic [2:0] amt,
    output logic [7:0] out
);

    logic [7:0] s0;
    logic [7:0] s1;
    //stage 0, shift 0 or 1 bit
    assign s0 =  amt[0]? {data[0], data[7:1]} :data ;
    //stage 1, shift 0 or 2 bits
    assign s1 =  amt[1]? {s0[1:0], s0[7:2]} :s0 ;
    //stage 1, shift 0 or 4 bits
    assign out = amt[2]?{s1[3:0], s1[7:4]} :s1;
endmodule

// rotates amt bits of data to the left
module barrel_shifter_left(
    input logic [7:0] data,
    input logic [2:0] amt,
    output logic [7:0] out
);

    logic [7:0] s0;
    logic [7:0] s1;
    //stage 0, shift 0 or 1 bit
    assign s0 = amt[0]? { data[6:0], data[7]} :data ;
    //stage 1, shift 0 or 2 bits
    assign s1 = amt[1]? { s0[5:0], s0[7:6]} :s0 ;
    //stage 1, shift 0 or 4 bits
    assign out = amt[2]?{s1[3:0], s1[7:4]} :s1;
endmodule

该代码包括两个 8 位旋转移位器，一个向右，一个向左。使用 1 至 2 多路复用器，选择移位器之一的输出。

在这里插入图片描述
两个扩展移位器，每个移位器有3个1对2多路复用器，用于3位移位量信号所需的每一级。
在这里插入图片描述
Test-bench and simulation
测试台代码循环遍历两种可能的移位情况（左和右）的所有可能的移位量可能性。

module barrel_shifter_multifunction_testbench;
    logic [7:0] data;
    logic [2:0] amt;
    logic [7:0] out;
    logic dir_lr;

    barrel_shifter_multifunction uut(.*);

    initial begin
        assign dir_lr = ROTATE_LEFT;
        for (byte i = 0; i < 8; ++i)
            begin
                data = 8'b1111_0000; amt = 3'(i); #10;
            end
        assign dir_lr = ROTATE_RIGHT;
        for (byte i = 0; i < 8; ++i)
            begin
                data = 8'b1111_0000; amt = 3'(i); #10;
            end
        $stop;
    end

Simulation

范围视图首先显示原始字符串 8’b1111_0000 的所有左移情况，然后显示所有右移情况
在这里插入图片描述
综合设计使用 44 个cells
在这里插入图片描述

Multi-function 8-bit barrel shifter with pre and post reversing circuits

该电路也可以通过一个带有前置和后置反转电路的旋转移位器来实现，因此基本的多路复用功能可以执行这两种操作。反转电路要么传递原始输入，要么按位反转输入。

`timescale 1ns / 10ps
const logic ROTATE_LEFT = 1'b1;
const logic ROTATE_RIGHT = 1'b0;

// Barrel Shifter using a Rotate-right-shifter with pre- and post-reversing circuits
module barrel_shifter_multi_rev(
    input logic [7:0] data,
    input logic [2:0] amt,
    input logic dir_lr, // 1 rotate left, 0 rotate right
    output logic [7:0] out
);
    logic [7:0] out_right; // output result
    logic [7:0] reversed_outr; // reversed output rotation for right rotation
    logic [7:0] reversed_data; // reversed input data for left rotation

    // if rotate left use rotated input data
    barrel_shifter_8_right bsr(.data((dir_lr == ROTATE_LEFT) ? reversed_data:data), .amt(amt) , .out(out_right));
    // reverse input circuit
    inverter_8 input_inverter(.data(data), .out(reversed_data));
    //  reverse output circuit
    inverter_8 output_inverter(.data(out_right), .out(reversed_outr));
    
     // if rotate right use rotated output  
    assign  out = (dir_lr == ROTATE_LEFT) ? reversed_outr:out_right;

endmodule

// reverse 8-bit data
module inverter_8(
    input logic [7:0] data,
    output logic [7:0] out
);
// reverse a vector using right-to-left streaming with the default block size of 1 bit 
  assign out = {<<{data}};  
endmodule
// rotates amt bits of data to the right
module barrel_shifter_8_right(
    input logic [7:0] data,
    input logic [2:0] amt,
    output logic [7:0] out
);

    logic [7:0] s0;
    logic [7:0] s1;
    //stage 0, shift 0 or 1 bit
    assign s0 =  amt[0]? {data[0], data[7:1]} :data ;
    //stage 1, shift 0 or 2 bits
    assign s1 =  amt[1]? {s0[1:0], s0[7:2]} :s0 ;
    //stage 1, shift 0 or 4 bits
    assign out = amt[2]?{s1[3:0], s1[7:4]} :s1;
endmodule

为了反转日期，使用从右到左的流式传输，默认块大小为 1 位：分配 out = {<<{data}};
Test bench

使用与前一个案例相同的测试平台。

`timescale 1ns / 10ps

module barrel_shifter_multi_rev_testbench;
    logic [7:0] data;
    logic [2:0] amt;
    logic [7:0] out;
    logic dir_lr;

    barrel_shifter_multi_rev uut(.*);

    initial begin
        assign dir_lr = ROTATE_LEFT;
        for (byte i = 0; i < 8; ++i)
            begin
                data = 8'b0000_0001; amt = 3'(i); #10;
            end
        assign dir_lr = ROTATE_RIGHT;
        for (byte i = 0; i < 8; ++i)
            begin
                data = 8'b0000_0001; amt = 3'(i); #10;
            end
        $stop;
    end

endmodule

Simulation
在本例中，使用字符串 8’b0000_0001 进行模拟
在这里插入图片描述
在精心设计的原理图中，可以观察到两个反转电路，它们反转输入和输出处的位位置。两个多路复用器根据移位方向和右移位电路选择非反相或反相输出输入。在这种情况下只需要一个移位器电路。

在这里插入图片描述综合设计使用了 44 cells.
在这里插入图片描述

Multi-function 32-bit barrel shifter with pre and post reversing circuits

将扩展之前的电路，使其能够处理 32 位长的字。

`timescale 1ns / 10ps
const logic ROTATE_LEFT = 1'b1;
const logic ROTATE_RIGHT = 1'b0;

module barrel_shifter_32_multi_rev(
    input logic [31:0] data,
    input logic [4:0] amt,
    input logic dir_lr, // 1 rotate left, 0 rotate right
    output logic [31:0] out
);
    logic [31:0] out_right;
    logic [31:0] reversed_outr;
    logic [31:0] reversed_data;
    
    barrel_shifter_32_right bsr(.data((dir_lr == ROTATE_LEFT) ? reversed_data:data), .amt(amt) , .out(out_right));
   
     // reverse input circuit
    inverter_32 input_inverter(.data(data), .out(reversed_data));
    //  reverse output circuit
    inverter_32 output_inverter(.data(out_right), .out(reversed_outr));
    
     // if rotate right use rotated output  
    assign  out = (dir_lr == ROTATE_LEFT) ? reversed_outr:out_right;

endmodule

// rotates amt bits of data to the right
module barrel_shifter_32_right(
    input logic [31:0] data,
    input logic [4:0] amt,
    output logic [31:0] out
);

    logic [31:0] s0;
    logic [31:0] s1;    
    logic [31:0] s2;
    logic [31:0] s3;

    //stage 0, shift 0 or 1 bit
    assign s0 =  amt[0]? {data[0], data[31:1]} :data ;
    //stage 1, shift 0 or 2 bits
    assign s1 =  amt[1]? {s0[1:0], s0[31:2]} :s0 ;
    //stage 2, shift 0 or 4 bits
    assign s2 = amt[2]?{s1[3:0], s1[31:4]} :s1;
    //stage 3, shift 0 or 8 bits
    assign s3 = amt[3]?{s2[7:0], s2[31:8]} :s2;
    //stage 4, shift 0 or 16 bits
    assign out = amt[4]?{s3[15:0], s3[31:16]} :s3;

endmodule

// reverse 32-bit data
module inverter_32(
    input logic [31:0] data,
    output logic [31:0] out    
);
// reverse a vector using right-to-left streaming with the default block size of 1 bit 
  assign out = {<<{data}};  
endmodule

主要变化影响数据信号的长度以及指示要移位量的信号。在这种情况下，对于 32 位，移位信号必须为 5 位长才能循环到所有情况。
右移电路也发生了变化，必须添加新的移位级才能达到所需的 5 个级。
Test bench
测试程序还必须适应新的尺寸。

`timescale 1ns / 10ps
module barrel_shifter_32_multi_rev_testbench;
    logic [31:0] data;
    logic [4:0] amt;
    logic [31:0] out;
    logic dir_lr;

    barrel_shifter_32_multi_rev uut(.*);

    initial begin         
        for (int i = 0; i < 32; ++i)
            begin
                data = 32'b1; amt = i; dir_lr = ROTATE_LEFT; #10;
            end
        for (int i = 0; i < 32; ++i)
            begin
                data = 32'b1; amt =i; dir_lr = ROTATE_RIGHT;  #10;
            end
        $stop;
    end

endmodule

Simulation
在本例中，使用字符串 32’b0000_0000_0000_0000_0000_0000_0000_0001 进行模拟
在这里插入图片描述
详细设计的方案与针对8位详细设计的方案类似，可以看到数据总线的大小发生了变化，它们已扩大到新的大小。
在这里插入图片描述
扩展桶形移位器块，发现由于需要新的移位级，多路复用器的数量有所增加。

综合设计变得越来越复杂。
在这里插入图片描述

Multi-function 32-bit barrel shifter with left shifter and right shifter multiplexing

可以使用 32 位长度执行与之前相同的练习，但在这种情况下，我们不使用前后反转电路，而是使用两个桶形移位器，一个向右，一个向左，可通过另一个多路复用器进行选择。

`timescale 1ns / 10ps
const logic ROTATE_LEFT = 1'b1;
const logic ROTATE_RIGHT = 1'b0;

module barrel_shifter_32_multi(
    input logic [31:0] data,
    input logic [4:0] amt,
    input logic dir_lr, // 1 rotate left, 0 rotate right
    output logic [31:0] out
);
    logic [31:0] out_right;
    logic [31:0] out_left;

    
    barrel_shifter_32_right bsr(.data(data), .amt(amt) , .out(out_right));
    barrel_shifter_32_left bsl(.data(data), .amt(amt) , .out(out_left));
    
     // if rotate right use rotated output  
    assign  out = (dir_lr == ROTATE_LEFT) ? out_left:out_right;

endmodule

// rotates amt bits of data to the right
module barrel_shifter_32_right(
    input logic [31:0] data,
    input logic [4:0] amt,
    output logic [31:0] out
);

    logic [31:0] s0;
    logic [31:0] s1;    
    logic [31:0] s2;
    logic [31:0] s3;

    //stage 0, shift 0 or 1 bit
    assign s0 =  amt[0]? {data[0], data[31:1]} :data ;
    //stage 1, shift 0 or 2 bits
    assign s1 =  amt[1]? {s0[1:0], s0[31:2]} :s0 ;
    //stage 2, shift 0 or 4 bits
    assign s2 = amt[2]?{s1[3:0], s1[31:4]} :s1;
    //stage 3, shift 0 or 8 bits
    assign s3 = amt[3]?{s2[7:0], s2[31:8]} :s2;
    //stage 4, shift 0 or 16 bits
    assign out = amt[4]?{s3[15:0], s3[31:16]} :s3;

endmodule

// rotates amt bits of data to the left
module barrel_shifter_32_left(
    input logic [31:0] data,
    input logic [4:0] amt,
    output logic [31:0] out
);

    logic [31:0] s0;
    logic [31:0] s1;    
    logic [31:0] s2;
    logic [31:0] s3;

    //stage 0, shift 0 or 1 bit
    assign s0 =  amt[0]? {data[30:0], data[31]} :data ;
    //stage 1, shift 0 or 2 bits
    assign s1 =  amt[1]? {s0[29:0], s0[31:30]} :s0 ;
    //stage 2, shift 0 or 4 bits
    assign s2 = amt[2]?{s1[27:0], s1[31:28]} :s1;
    //stage 3, shift 0 or 8 bits
    assign s3 = amt[3]?{s2[23:0], s2[31:24]} :s2;
    //stage 4, shift 0 or 16 bits
    assign out = amt[4]?{s3[15:0], s3[31:16]} :s3;

endmodule

module barrel_shifter_32_multi_testbench;
    logic [31:0] data;
    logic [4:0] amt;
    logic [31:0] out;
    logic dir_lr;

    barrel_shifter_32_multi uut(.*);

    initial begin         
        for (int i = 0; i < 32; ++i)
            begin
                data = 32'b1; amt = i; dir_lr = ROTATE_LEFT; #10;
            end
        for (int i = 0; i < 32; ++i)
            begin
                data = 32'b1; amt =i; dir_lr = ROTATE_RIGHT;  #10;
            end
        $stop;
    end

endmodule

该代码包括之前的右桶形移位器，并在左侧的相反方向添加一个新的移位器。根据地址信号 dir_lr 选择其中之一。
在这里插入图片描述
扩展两个桶形移位器，可以看到该解决方案比前一个解决方案需要更多的多路复用器。
在这里插入图片描述Test bench
可以使用与之前的情况类似的测试平台，但更改被测单元 uut 的实例化。

module barrel_shifter_32_multi_testbench;
    logic [31:0] data;
    logic [4:0] amt;
    logic [31:0] out;
    logic dir_lr;

    barrel_shifter_32_multi uut(.*);

    initial begin         
        for (int i = 0; i < 32; ++i)
            begin
                data = 32'b1; amt = i; dir_lr = ROTATE_LEFT; #10;
            end
        for (int i = 0; i < 32; ++i)
            begin
                data = 32'b1; amt =i; dir_lr = ROTATE_RIGHT;  #10;
            end
        $stop;
    end

endmodule

Simulation

在模拟中，可以以图形方式看到偏移如何影响高位的单个位。
在这里插入图片描述
综合设计与前一个类似，有 198 cells

在这里插入图片描述

Parameterizable word width multifunction barrel shifter

最后制作一个具有可参数化数据长度的版本。
在这个参数化的桶形移位器中，输入宽度可以由参数 N N N 指定。输入的宽度将为 2 N 2^N 2N

`timescale 1ns / 1ps
const logic ROTATE_LEFT = 1'b1;
const logic ROTATE_RIGHT = 1'b0;
// The width of input will be 2^N  ie N=5 width 32
module barrel_shifter_N #(parameter N=4) (
    input logic [2**N-1:0] data,
    input logic [N-1:0] amt,
    input logic dir_lr, // 1 rotate left, 0 rotate right
    output logic [2**N-1:0] out
);
    localparam WIDTH = 2**N;
    logic [WIDTH-1:0] out_right;
    logic [WIDTH-1:0] reversed_outr;
    logic [WIDTH-1:0] reversed_data;

    barrel_shifter_N_right #(.N(N)) bsr(.data((dir_lr == ROTATE_LEFT) ? reversed_data:data), .amt(amt) , .out(out_right));

    // reverse input circuit
    inverter_width #(.WIDTH(WIDTH)) input_inverter(.data(data), .out(reversed_data));
    //  reverse output circuit
    inverter_width #(.WIDTH(WIDTH))output_inverter(.data(out_right), .out(reversed_outr));

    // if rotate right use rotated output  
    assign  out = (dir_lr == ROTATE_LEFT) ? reversed_outr:out_right;

endmodule

// rotates amt bits of data to the right staged implementation
//
module barrel_shifter_N_right #(parameter N = 4)(
    input logic [2**N-1:0] data,
    input logic [N-1:0] amt,
    output logic [2**N-1:0] out
);

    localparam WIDTH = 2**N;
    logic  [N-1:0][WIDTH-1:0] stage_out;

    generate
        genvar  stage ;
        assign stage_out[0] = amt[0] ? { data[0], data[WIDTH-1:1]} : data;
        for (stage = 1; stage < N ; ++stage)
        begin
            assign stage_out[stage] = amt[stage] ?
                {stage_out[stage-1][stage**2:0], stage_out[stage-1][WIDTH-1:2**stage]}
                : stage_out[stage -1];
        end
        assign out = stage_out[N-1];
    endgenerate

endmodule

// reverse 32-bit data
module inverter_width #(parameter WIDTH=32) (
    input logic [WIDTH-1:0] data,
    output logic [WIDTH-1:0] out
);
    // reverse a vector using right-to-left streaming with the default block size of 1 bit 
    assign out = {<<{data}};
endmodule

module barrel_shifter_N_testbench;

    localparam N = 3;
    localparam WIDTH = 2**N;
    
    logic [WIDTH-1:0] data;
    logic [N-1:0] amt;
    logic [WIDTH-1:0] out;
    logic dir_lr;

    barrel_shifter_N #(.N(N)) uut(.*);

    initial begin
        for (int i = 0; i < WIDTH; ++i)
            begin
                data = 5; amt = i; dir_lr = ROTATE_LEFT; #10;
            end
        for (int i = 0; i < WIDTH; ++i)
            begin
                data = 5; amt =i; dir_lr = ROTATE_RIGHT;  #10;
            end
        $stop;
    end

endmodule

由于现在移动数据的阶段数是可变的，可以使用生成块在循环中生成不同的必要阶段。

在这里插入图片描述
模拟 N = 3，字宽 = 8，
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

疯狂的码泰君
关注
  • 33
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
用Verilog实现一个桶形移位器
Scott Wang's blog
11-24 2万+
实验六 桶型移位器实验介绍本实验使用Verilog语言设计实现一个32位桶型移位器。实验目标 1. 使用ISE软件设计并进行仿真 2. 学会使用Modelsim 3. 理解桶型移位器原理，使用logicsim软件搭建一个8位的桶型移位器 4. 用verilog实现一个32位桶型移位器实验原理 桶型移位器是一个多输入、单输出电路。对于输入a[31:0]，移位器首先会根据aluc[1:0]值来
桶形移位器，8,16,32位及ARM实现
03-08
桶形移位器，8位，16位，32位，含ARM桶形移位器。南大计算机系计算机组成原理实验-Barrel shifter, 8, 16, 32, including the ARM barrel shifter. NJU Department of Computer Science Experimental Computer System
桶型移位寄存器的VHDL实现
通信系统、数字信号处理、FPGA
10-20 180
对输入的8位宽信号INP逻辑左移，左移的位数是3位宽信号SHIFT决定，输出是OUTP。
m基于FPGA的桶形移位寄存器verilog实现,包含testbench
fpga/matlab/simulink算法仿真工程
06-25 1427
每个触发器的输出连接一个异或门，其中一个输入为其输入，另一个输入为反馈路径上的某些输出的异或和。下面给出一个示例，演示如何实现一个长度为4的桶形移位寄存器，其多项式为$S(x)=x^4+x+1$，反馈路径上的比特位置为$T_1=4$和$T_2=3$。其中，s_n表示第n个时刻的输出比特，D表示移位寄存器的长度，T_1,\cdots,T_d表示反馈路径上的比特位置，\oplus表示异或运算。选择一个合适的多项式S(x)，并确定移位寄存器的长度$D$和反馈路径上的比特位置T_1,\cdots,T_d。
【verilog】桶形移位器组合逻辑，输入为32位二进制向量，根据方向和位移值输出循环移位后的32位结果
06-20
实现桶形移位器组合逻辑，要实现的功能如下： 输入为32位二进制向量，根据方向和位移值输出循环移位后的32位结果。例如： 输入向量00011000101000000000000000000000，方向左，位移值10，输出向量10000000000000000000000001100010； 输入向量00000000111111110000000000000011，方向右，位移植20，输出向量11110000000000000011000000001111. 顶层模块名为bsh_32，输入输出功能定义： 名称 方向 位宽 描述 data_in I 32 输入数据 dir I 1 位移方向 0：循环左移 1：循环右移 sh I 5 位移值，取值0~31 data_out O 32 输出数据 设计要求： Verilog实现代码可综合，逻辑延迟越小越好，给出综合以及仿真结果。
桶形移位器
热门推荐
spx1164376416的博客
06-07 1万+
桶型移位电路
Verilog复杂逻辑设计指南-奇偶校验生成器和校验器及筒式移位器
OpenFPGA的博客
03-15 1473
使用Verilog可以方便地实现复杂的设计。现在，设计复杂性增加，设计需要针对低功率、高速和最小面积进行优化~在大多数实际的ASIC/FPGA和SOC设计中，Verilog RTL用于描述...
barrel_shift.rar_barrel shifter_shift_shifter
09-24
This project si barrel shifter for an 8-bit
barrel shifter
12-21
barrel shifter的三种设计方案
Barrel Shifter
05-27
Barrel Shifter design
桶形移位器的Verilog HDL设计
10-14
包含了3种设计：MIPS32位、8位桶形移位器、ARMS32位
Verilog语言编写32位桶形移位器（含仿真代码）.pdf
01-30
数字逻辑基础与Verilog设计
32位Arm桶型移位器
03-02
32位桶型移位器 使用了Barrel Shifter模板 已经成功通过编译和仿真 （环境 Quartus12.0）
32位桶式移位寄存器的FPGA实现
07-24
基于fpga的32位桶式移位寄存器实现，参考文档《三十位桶式移位寄存器的FPGA实现--杜慧敏》
Python实现桶排序与快速排序算法结合应用示例
09-21
在给出的代码中，`BucketSort`函数首先初始化一个空的字典`barrel`，用于存储各个桶中的元素。接着，找到输入数组`a`的最小值`min`和最大值`max`，并计算每个桶的边界。遍历数组`a`，根据每个元素的值将其分配到对应...
第3关：32位移位器设计
平安喜乐
12-21 2303
用Verilog HDL设计译码器、多路选择器、移位器。
简单移位器结构介绍
qq_45776815的博客
05-31 2301
其实是一个复杂的多路开关电路，根据不同控制信号，将输入左移或右移或不变。多位的移位可以简单串联这样的单元实现，但移位位数多时，该方法过于复杂，不实用并且速度很慢。由晶体管阵列构成，行数等于数据字长，列数等于最大移位宽度。桶形移位器实现为传输管的单个阵列，而对数移位器采用分级的方法。移位值分解为几个2的指数值。log2​M。
关于桶形移位寄存器的讨论
justlxy的博客
04-04 6241
桶形移位寄存器即循环移位寄存器，在浮点加减运算、压缩/解压缩和图像处理算法中有应用，所以稍微说明下： 例如设计一个8位桶形移位器：8位桶形移位器是有8个数据输入位，8个数据输出位和3个控制输入位的组合逻辑电路，其输出字等于输入字的循环移位，循环移位的次数由控制输入位指定。比如，如果输入字等于ABCDEFGH（每个字母表示一位），且输入控制位为101（5），则输出字为FGHABCDE。 学校里的一些教材给出的写法是： module barrel_shifter(data,num,out); i
三十二位桶形移位器verilog
最新发布
12-07
三十二位桶形移位器（32-bit barrel shifter）是一种硬件电路，用于对32位二进制数进行移位操作，它可以实现向左移位和向右移位。 这种移位器使用Verilog语言进行描述和实现。Verilog是一种硬件描述语言，用于电子设计自动化中的数字电路的描述和建模。 在Verilog中，可以使用位向量（bit vector）来表示和操作32位二进制数。首先，需要定义输入和输出端口，分别表示32位的输入数据和移位后的输出数据。然后，使用逻辑门和连续赋值语句来实现移位操作。 对于向左移位，可以使用循环语句将每一位的输入数据赋值给输出数据的相应位置。例如，输出数据的第一位等于输入数据的第二位，第二位等于输入数据的第三位，以此类推，最后一位等于输入数据的第一位。 对于向右移位，可以使用逻辑门和选择语句来实现。首先，将输出数据的第一位等于输入数据的最后一位。然后，使用选择语句将输入数据的每一位依次连接到输出数据的对应位置。 需要注意的是，在Verilog中，数据的最高位是符号位，因此，在进行向左移位或向右移位时，必须要考虑到符号位。对于有符号数，应该保持符号位不变，只移动其他位。 最后，编写的Verilog代码需要进行仿真和综合。仿真可以通过提供测试用例来验证移位器的正确性。综合可以将Verilog代码转化为实际的硬件电路来实现移位操作。 总之，三十二位桶形移位器是一种用Verilog语言描述和实现的硬件电路，用于对32位二进制数进行移位操作。通过定义输入和输出端口，并使用逻辑门和连续赋值语句，可以实现向左移位和向右移位的功能。经过仿真和综合，可以验证和实现这种移位器的正确性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

疯狂的码泰君

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

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

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

打赏作者

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

抵扣说明：

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

余额充值