Является ли поведение регистра сдвига стандартной библиотеки долота правильным для линии включения

Question

Я пытаюсь создать путь данных, который включает в себя регистр сдвига, но я хочу, чтобы все это могло быть остановлено во время ожидания на новом входе , Я видел, что в стандартной библиотеке есть сдвиговый регистр с разрешающей строкой (хотя по умолчанию это верно).

Проблема заключается в том, что когда я пытаюсь ее использовать, скомпилированный верилог, похоже, фактически не останавливает сдвиговый регистр, когда разрешено низкое.

Рассмотрим долото код:

package SR 

import Chisel._ 

class SR extends Module { 
    val io = new Bundle { 
    val in = UInt(INPUT, 8) 
    val enable = Bool(INPUT) 
    val out = UInt(OUTPUT, 8) 
    } 
    io.out:= ShiftRegister(io.in, 10, io.enable) 
} 

class SRTests(c: SR) extends Tester(c) { 
} 

object SR { 
    def main(args: Array[String]): Unit = { 
    val tutArgs = args.slice(1, args.length) 
    chiselMainTest(tutArgs,() => Module(new SR())) { 
     c => new SRTests(c) } 
    } 
} 

Я получаю следующее Verilog:

module SR(input clk, 
    input [7:0] io_in, 
    input io_enable, 
    output[7:0] io_out 
); 

    reg [7:0] R0; 
    reg [7:0] R1; 
    reg [7:0] R2; 
    reg [7:0] R3; 
    reg [7:0] R4; 
    reg [7:0] R5; 
    reg [7:0] R6; 
    reg [7:0] R7; 
    reg [7:0] R8; 
    reg [7:0] R9; 
    wire[7:0] T10; 

`ifndef SYNTHESIS 
    integer initvar; 
    initial begin 
    #0.002; 
    R0 = {1{$random}}; 
    R1 = {1{$random}}; 
    R2 = {1{$random}}; 
    R3 = {1{$random}}; 
    R4 = {1{$random}}; 
    R5 = {1{$random}}; 
    R6 = {1{$random}}; 
    R7 = {1{$random}}; 
    R8 = {1{$random}}; 
    R9 = {1{$random}}; 
    end 
`endif 

    assign io_out = R0; 
    assign T10 = io_enable ? io_in : R9; 

    always @(posedge clk) begin 
    R0 <= R1; 
    R1 <= R2; 
    R2 <= R3; 
    R3 <= R4; 
    R4 <= R5; 
    R5 <= R6; 
    R6 <= R7; 
    R7 <= R8; 
    R8 <= R9; 
    if(io_enable) begin 
     R9 <= io_in; 
    end 
    end 
endmodule 

Похоже, регистр сдвига только держит первое фиксированное значение, а не все это. Например, если вы написали в 1,2,3,4,5 на последовательных тактовых циклах, но только удерживали разрешение высокой для 1, 2, 3, 3 было бы правильно проведено, но 1 и 2 в конечном итоге сдвигались бы и весь регистр сдвига будет заполняться значением 3.

Я бы хотел, чтобы поведение, подобное примеру регистра сдвига, было видно в учебнике долота. Проблема в том, что мне нужны длинные, параметризуемые регистры сдвига, поэтому запись вручную каждого регистра не является вариантом. Я был бы чрезвычайно признателен за пример кода долота, который реализует сдвиговый регистр с включенным поведением, как показано в учебнике долота, но параметризатор для разных длин, как это видно в стандартной библиотеке.

Answer 1

Вы можете увидеть исходный код ShiftRegister в И/Главном// ChiselUtil.scala лестницы в Chisel хранилище:

object ShiftRegister 
{ 
    def apply[T <: Data](in: T, n: Int, en: Bool = Bool(true)): T = 
    { 
    // The order of tests reflects the expected use cases. 
    if (n == 1) { 
     RegEnable(in, en) 
    } else if (n != 0) { 
     RegNext(apply(in, n-1, en)) 
    } else { 
     in 
    } 
    } 
} 

, которая создает рекурсивную цепочку RegNexts, но с базовым случаем создание RegEnable. Пример:

RegNext(RegNext(RegNext(RegEnable(in, en)))) 

Вы можете скопировать этот код на свой привет мир, переименовать его что-то вроде object MyShiftRegister, а затем изменить этот цикл, чтобы удовлетворить ваши потребности.

Я думаю, что вы ищете:

} else if (n != 0) { 
    RegEnable(apply(in, n-1, en), en) 
} ... 

В качестве общей стратегии, я предлагаю писать, что код будет выглядеть «не-прокатке», а затем думать о том, как «упаковать его "в краткую и параметризуемую часть кода Scala.