Galeria de projetos e testbenches

Esta galeria reúne exemplos pequenos para praticar o fluxo completo de simulação na AURORA. Cada circuito ou algoritmo possui duas alternativas de teste: um testbench Verilog (.v) e um testbench cocotb (.py). Use apenas uma alternativa como Testbench Top em cada execução.

Como usar os exemplos

Para um exemplo Verilog:

1. Baixe ou copie os três arquivos do conjunto para a pasta do projeto.

2. Adicione o arquivo do circuito como fonte sintetizável.

3. Defina o arquivo do circuito como Top Level.

4. Adicione tb_*.v ou test_*.py como testbench.

5. Defina o testbench escolhido como Testbench Top.

6. Execute Analisar Verilog (forma de onda) para abrir as formas de onda ou Execução rápida para conferir apenas as verificações.

Para um exemplo C±:

1. Crie no Hub de Processadores um processador com o mesmo nome indicado por #PRNAME.

2. Substitua o conteúdo do arquivo em Software pelo exemplo .cmm.

3. Execute C± para gerar o módulo em Hardware/<nome>.v e os arquivos de memória necessários.

4. Adicione o testbench .v ou .py correspondente ao projeto.

5. Defina Hardware/<nome>.v como Top Level e o teste escolhido como Testbench Top.

6. Execute Analisar Verilog (forma de onda) ou Execução rápida.

Importante

Os testbenches dos exemplos C± exercitam o Verilog gerado pelo compilador. Compile o .cmm antes da simulação e mantenha os arquivos gerados pela AURORA no projeto. O arquivo Python não executa C± diretamente.

Porta AND em Verilog

Este primeiro conjunto cobre um circuito combinacional. Os quatro pares possíveis de entrada são aplicados, e cada saída é comparada com a tabela-verdade da operação AND.

Arquivos: porta_and.v, tb_porta_and.v e test_porta_and.py.

Circuito porta_and.v

module porta_and (
    input  wire a,
    input  wire b,
    output wire y
);
    assign y = a & b;
endmodule

Testbench Verilog tb_porta_and.v

`timescale 1ns/1ps

module tb_porta_and;
    reg a;
    reg b;
    wire y;

    porta_and dut (
        .a(a),
        .b(b),
        .y(y)
    );

    task verificar;
        input valor_a;
        input valor_b;
        input esperado;
        begin
            a = valor_a;
            b = valor_b;
            #1;

            if (y !== esperado) begin
                $display(
                    "ERRO: a=%0b b=%0b esperado=%0b obtido=%0b",
                    a, b, esperado, y
                );
                $fatal(1);
            end
        end
    endtask

    initial begin
        $dumpfile("tb_porta_and.vcd");
        $dumpvars(0, tb_porta_and);

        verificar(1'b0, 1'b0, 1'b0);
        verificar(1'b0, 1'b1, 1'b0);
        verificar(1'b1, 1'b0, 1'b0);
        verificar(1'b1, 1'b1, 1'b1);

        $display("SUCESSO: tabela verdade validada.");
        $finish;
    end
endmodule

O bloco task verificar evita repetir a sequência de atribuição, espera e comparação. $fatal(1) encerra a execução com falha assim que um caso produz uma saída incorreta. $dumpfile e $dumpvars registram os sinais para o viewer de ondas.

Testbench cocotb test_porta_and.py

# aurora-toplevel: porta_and

import cocotb
from cocotb.triggers import Timer


async def verificar(dut, valor_a, valor_b, esperado):
    dut.a.value = valor_a
    dut.b.value = valor_b
    await Timer(1, unit="ns")

    obtido = int(dut.y.value)
    assert obtido == esperado, (
        f"a={valor_a} b={valor_b}: esperado={esperado}, obtido={obtido}"
    )


@cocotb.test()
async def testa_tabela_verdade(dut):
    casos = [
        (0, 0, 0),
        (0, 1, 0),
        (1, 0, 0),
        (1, 1, 1),
    ]

    for valor_a, valor_b, esperado in casos:
        await verificar(dut, valor_a, valor_b, esperado)

A diretiva # aurora-toplevel: porta_and seleciona explicitamente o módulo testado. A função auxiliar aplica um caso, aguarda a propagação combinacional e inclui entradas, valor esperado e valor obtido na mensagem da asserção.

Contador de 4 bits em Verilog

Este conjunto introduz clock, reset e controle de habilitação. O teste confirma que o reset zera o estado, que o contador avança a cada borda quando enable vale 1 e que o valor permanece estável quando enable vale 0.

Arquivos: contador4.v, tb_contador4.v e test_contador4.py.

Circuito contador4.v

module contador4 (
    input  wire       clk,
    input  wire       rst,
    input  wire       enable,
    output reg  [3:0] valor
);
    always @(posedge clk) begin
        if (rst)
            valor <= 4'd0;
        else if (enable)
            valor <= valor + 4'd1;
    end
endmodule

Testbench Verilog tb_contador4.v

`timescale 1ns/1ps

module tb_contador4;
    reg clk = 1'b0;
    reg rst = 1'b1;
    reg enable = 1'b0;
    wire [3:0] valor;

    contador4 dut (
        .clk(clk),
        .rst(rst),
        .enable(enable),
        .valor(valor)
    );

    always #5 clk = ~clk;

    initial begin
        $dumpfile("tb_contador4.vcd");
        $dumpvars(0, tb_contador4);

        repeat (2) @(posedge clk);
        @(negedge clk);
        rst = 1'b0;
        enable = 1'b1;

        repeat (4) @(posedge clk);
        #1;
        if (valor !== 4'd4) begin
            $display("ERRO: esperado=4 obtido=%0d", valor);
            $fatal(1);
        end

        @(negedge clk);
        enable = 1'b0;
        repeat (2) @(posedge clk);
        #1;
        if (valor !== 4'd4) begin
            $display("ERRO: contador mudou com enable=0. obtido=%0d", valor);
            $fatal(1);
        end

        $display("SUCESSO: reset, contagem e enable validados.");
        $finish;
    end
endmodule

O clock alterna a cada 5 ns, portanto o período é de 10 ns. O reset é retirado na borda de descida para estar estável antes da próxima borda de subida. O atraso #1 após a borda permite observar o valor atualizado pela atribuição não bloqueante do contador.

Testbench cocotb test_contador4.py

# aurora-toplevel: contador4

import cocotb
from cocotb.clock import Clock
from cocotb.triggers import FallingEdge, ReadOnly, RisingEdge


async def ler_apos_borda(dut):
    await RisingEdge(dut.clk)
    await ReadOnly()
    return int(dut.valor.value)


@cocotb.test()
async def testa_reset_contagem_e_enable(dut):
    cocotb.start_soon(Clock(dut.clk, 10, unit="ns").start())

    dut.rst.value = 1
    dut.enable.value = 0
    await ler_apos_borda(dut)
    assert await ler_apos_borda(dut) == 0, "O reset nao zerou o contador."

    await FallingEdge(dut.clk)
    dut.rst.value = 0
    dut.enable.value = 1
    for esperado in range(1, 5):
        obtido = await ler_apos_borda(dut)
        assert obtido == esperado, (
            f"Contagem incorreta: esperado={esperado}, obtido={obtido}"
        )

    await FallingEdge(dut.clk)
    dut.enable.value = 0
    for _ in range(2):
        obtido = await ler_apos_borda(dut)
        assert obtido == 4, (
            f"O contador mudou com enable=0: esperado=4, obtido={obtido}"
        )

Clock gera o clock em uma corrotina separada. A função ler_apos_borda aguarda RisingEdge e depois ReadOnly, fase em que as atualizações daquele instante já podem ser lidas sem disputar com a lógica do simulador. As mudanças de rst e enable são feitas após FallingEdge, fora da fase somente de leitura e antes da próxima borda ativa.

Soma de constantes em C±

Este exemplo gera um processador chamado soma_constantes. O algoritmo soma 3 + 4, escreve 7 na porta de saída 0 e alcança #TOAQUI, que permite ao hardware indicar o término pelo sinal cheguei.

Arquivos: soma_constantes.cmm, tb_soma_constantes.v e test_soma_constantes.py.

Algoritmo soma_constantes.cmm

#PRNAME soma_constantes
#NUBITS 32
#NBMANT 23
#NBEXPO 8
#NDSTAC 8
#SDEPTH 8
#NUIOIN 1
#NUIOOU 1
#NUGAIN 128

void main()
{
    int a = 3;
    int b = 4;
    int resultado;

    resultado = a + b;
    out(0, resultado);

    #TOAQUI
}

Testbench Verilog tb_soma_constantes.v

`timescale 1ns/1ps

module tb_soma_constantes;
    reg clk = 1'b0;
    reg rst = 1'b1;
    wire signed [31:0] out;
    wire [0:0] out_en;
    wire cheguei;

    integer ciclos = 0;
    integer recebeu_saida = 0;
    integer terminou = 0;

    soma_constantes dut (
        .clk(clk),
        .rst(rst),
        .out(out),
        .out_en(out_en),
        .cheguei(cheguei)
    );

    always #5 clk = ~clk;

    always @(posedge clk) begin
        if (!rst && (out_en == 1)) begin
            recebeu_saida = 1;
            if ($signed(out) !== 32'sd7) begin
                $display("ERRO: esperado=7 obtido=%0d", $signed(out));
                $fatal(1);
            end
        end

        if (cheguei === 1'b1)
            terminou = 1;
    end

    initial begin
        $dumpfile("tb_soma_constantes.vcd");
        $dumpvars(0, tb_soma_constantes);

        repeat (2) @(posedge clk);
        @(negedge clk);
        rst = 1'b0;

        while (!terminou && (ciclos < 200)) begin
            @(posedge clk);
            ciclos = ciclos + 1;
        end

        repeat (2) @(posedge clk);
        #1;

        if (!recebeu_saida) begin
            $display("ERRO: nenhuma escrita foi observada na porta 0.");
            $fatal(1);
        end

        if (!terminou) begin
            $display("ERRO: tempo limite antes de #TOAQUI.");
            $fatal(1);
        end

        $display("SUCESSO: saida 7 e termino do algoritmo validados.");
        $finish;
    end
endmodule

O bloco acionado na borda de subida observa out_en == 1, condição que identifica uma escrita na porta 0. A captura ocorre na própria borda porque esse sinal funciona como um pulso de habilitação da escrita. O limite de 200 ciclos evita uma simulação infinita se o algoritmo não produzir a saída ou não alcançar #TOAQUI.

Testbench cocotb test_soma_constantes.py

# aurora-toplevel: soma_constantes

import cocotb
from cocotb.clock import Clock
from cocotb.triggers import FallingEdge, ReadOnly, RisingEdge


@cocotb.test()
async def testa_soma_e_termino(dut):
    cocotb.start_soon(Clock(dut.clk, 10, unit="ns").start())

    dut.rst.value = 1
    for _ in range(2):
        await RisingEdge(dut.clk)
    await FallingEdge(dut.clk)
    dut.rst.value = 0

    saidas = []
    ciclos_apos_termino = 0
    for _ in range(200):
        await FallingEdge(dut.clk)
        await ReadOnly()

        if int(dut.out_en.value) == 1:
            saidas.append(int(dut.out.value))

        if int(dut.cheguei.value) == 1 and ciclos_apos_termino == 0:
            ciclos_apos_termino = 1
        elif ciclos_apos_termino:
            ciclos_apos_termino += 1

        if ciclos_apos_termino >= 3:
            break
    else:
        raise AssertionError("Tempo limite antes de o algoritmo atingir #TOAQUI.")

    assert saidas == [7], f"Esperado [7] na porta 0, obtido {saidas}."

O teste amostra out_en, out e cheguei na borda de descida do clock, quando os sinais produzidos na borda ativa já estão estáveis. Ele exige a lista exata [7]; dessa forma, detecta ausência de saída, valor incorreto e escritas adicionais inesperadas. O limite de ciclos impede uma espera infinita.

Sequência de quadrados em C±

Este exemplo usa um laço while para escrever 0, 1, 4 e 9 na porta 0. Além do valor de cada amostra, os testes verificam a ordem e a quantidade de escritas.

Arquivos: sequencia_quadrados.cmm, tb_sequencia_quadrados.v e test_sequencia_quadrados.py.

Algoritmo sequencia_quadrados.cmm

#PRNAME sequencia_quadrados
#NUBITS 32
#NBMANT 23
#NBEXPO 8
#NDSTAC 8
#SDEPTH 8
#NUIOIN 1
#NUIOOU 1
#NUGAIN 128

void main()
{
    int indice = 0;

    while (indice < 4) {
        out(0, indice * indice);
        indice = indice + 1;
    }

    #TOAQUI
}

Testbench Verilog tb_sequencia_quadrados.v

`timescale 1ns/1ps

module tb_sequencia_quadrados;
    reg clk = 1'b0;
    reg rst = 1'b1;
    wire signed [31:0] out;
    wire [0:0] out_en;
    wire cheguei;

    integer ciclos = 0;
    integer indice = 0;
    integer terminou = 0;
    integer esperado [0:3];

    sequencia_quadrados dut (
        .clk(clk),
        .rst(rst),
        .out(out),
        .out_en(out_en),
        .cheguei(cheguei)
    );

    always #5 clk = ~clk;

    always @(posedge clk) begin
        if (!rst && (out_en == 1)) begin
            if (indice > 3) begin
                $display("ERRO: o processador produziu saidas extras.");
                $fatal(1);
            end

            if ($signed(out) !== esperado[indice]) begin
                $display(
                    "ERRO: indice=%0d esperado=%0d obtido=%0d",
                    indice, esperado[indice], $signed(out)
                );
                $fatal(1);
            end

            indice = indice + 1;
        end

        if (cheguei === 1'b1)
            terminou = 1;
    end

    initial begin
        esperado[0] = 0;
        esperado[1] = 1;
        esperado[2] = 4;
        esperado[3] = 9;

        $dumpfile("tb_sequencia_quadrados.vcd");
        $dumpvars(0, tb_sequencia_quadrados);

        repeat (2) @(posedge clk);
        @(negedge clk);
        rst = 1'b0;

        while (!terminou && (ciclos < 400)) begin
            @(posedge clk);
            ciclos = ciclos + 1;
        end

        repeat (2) @(posedge clk);
        #1;

        if (indice !== 4) begin
            $display("ERRO: esperadas=4 saidas_recebidas=%0d", indice);
            $fatal(1);
        end

        if (!terminou) begin
            $display("ERRO: tempo limite antes de #TOAQUI.");
            $fatal(1);
        end

        $display("SUCESSO: sequencia 0, 1, 4, 9 validada.");
        $finish;
    end
endmodule

O vetor esperado funciona como um modelo de referência simples. Cada pulso de out_en consome uma posição. O teste falha se houver valor incorreto, quantidade diferente de quatro saídas ou ausência do sinal de término.

Testbench cocotb test_sequencia_quadrados.py

# aurora-toplevel: sequencia_quadrados

import cocotb
from cocotb.clock import Clock
from cocotb.triggers import FallingEdge, ReadOnly, RisingEdge


@cocotb.test()
async def testa_sequencia_e_termino(dut):
    cocotb.start_soon(Clock(dut.clk, 10, unit="ns").start())

    dut.rst.value = 1
    for _ in range(2):
        await RisingEdge(dut.clk)
    await FallingEdge(dut.clk)
    dut.rst.value = 0

    saidas = []
    ciclos_apos_termino = 0
    for _ in range(400):
        await FallingEdge(dut.clk)
        await ReadOnly()

        if int(dut.out_en.value) == 1:
            saidas.append(int(dut.out.value))

        if int(dut.cheguei.value) == 1 and ciclos_apos_termino == 0:
            ciclos_apos_termino = 1
        elif ciclos_apos_termino:
            ciclos_apos_termino += 1

        if ciclos_apos_termino >= 3:
            break
    else:
        raise AssertionError("Tempo limite antes de o algoritmo atingir #TOAQUI.")

    assert saidas == [0, 1, 4, 9], (
        f"Esperado [0, 1, 4, 9] na porta 0, obtido {saidas}."
    )

A lista Python torna a comparação da sequência inteira direta. Esse padrão pode ser ampliado para filtros, máquinas de estados e processadores que produzam séries de amostras.

Escolher entre os dois tipos de testbench

Situação	Testbench recomendado
Aprender eventos e tarefas do Verilog	.v
Controlar diretamente o dump de sinais	.v
Percorrer muitos casos de entrada	.py com cocotb
Criar listas, modelos matemáticos e mensagens detalhadas	.py com cocotb
Depurar a integração inicial de um módulo	Comece com .v e reproduza em .py quando necessário

Os dois formatos verificam o mesmo hardware. A escolha altera a linguagem e a organização do teste, não o circuito sintetizável. Para o procedimento de execução e o diagnóstico de falhas, consulte Simular com Icarus, Verilator ou cocotb.